44 template <
typename Derived>
45 dyn_mat<typename Derived::Scalar>
56 return rA.transpose();
66 template <
typename Derived>
67 dyn_mat<typename Derived::Scalar>
78 return rA.conjugate();
88 template <
typename Derived>
109 template <
typename Derived>
129 template <
typename Derived>
130 typename Derived::Scalar
trace(
const Eigen::MatrixBase<Derived>& A) {
150 template <
typename Derived>
151 typename Derived::Scalar
det(
const Eigen::MatrixBase<Derived>& A) {
161 return rA.determinant();
173 template <
typename Derived>
174 typename Derived::Scalar
logdet(
const Eigen::MatrixBase<Derived>& A) {
188 Eigen::PartialPivLU<dyn_mat<typename Derived::Scalar>> lu(rA);
190 lu.matrixLU().template triangularView<Eigen::Upper>();
191 typename Derived::Scalar result = std::log(U(0, 0));
193 for (
idx i = 1; i < static_cast<idx>(rA.rows()); ++i)
194 result += std::log(U(i, i));
206 template <
typename Derived>
207 typename Derived::Scalar
sum(
const Eigen::MatrixBase<Derived>& A) {
227 template <
typename Derived>
228 typename Derived::Scalar
prod(
const Eigen::MatrixBase<Derived>& A) {
247 template <
typename Derived>
248 double norm(
const Eigen::MatrixBase<Derived>& A) {
259 return (rA.template cast<cplx>()).norm();
268 template <
typename Derived>
269 dyn_mat<typename Derived::Scalar>
283 double normA =
norm(rA);
286 throw std::overflow_error(
"Division by zero!");
288 std::cerr <<
"In qpp::normalize()\n";
293 typename Derived::Scalar traceA =
trace(rA);
295 if (std::abs(traceA) == 0)
296 throw std::overflow_error(
"Division by zero!");
298 std::cerr <<
"In qpp::normalize()\n";
301 result = rA /
trace(rA);
316 template <
typename Derived>
317 std::pair<dyn_col_vect<cplx>,
cmat>
eig(
const Eigen::MatrixBase<Derived>& A) {
331 Eigen::ComplexEigenSolver<cmat> es(rA.template cast<cplx>());
333 return std::make_pair(es.eigenvalues(), es.eigenvectors());
343 template <
typename Derived>
358 return eig(rA).first;
368 template <
typename Derived>
383 Eigen::ComplexEigenSolver<cmat> es(rA.template cast<cplx>());
385 return eig(rA).second;
396 template <
typename Derived>
397 std::pair<dyn_col_vect<double>,
cmat>
398 heig(
const Eigen::MatrixBase<Derived>& A) {
412 Eigen::SelfAdjointEigenSolver<cmat> es(rA.template cast<cplx>());
414 return std::make_pair(es.eigenvalues(), es.eigenvectors());
424 template <
typename Derived>
439 return heig(rA).first;
449 template <
typename Derived>
464 return heig(rA).second;
476 template <
typename Derived>
477 std::tuple<cmat, dyn_col_vect<double>,
cmat>
479 svd(
const Eigen::MatrixBase<Derived>& A) {
489 Eigen::JacobiSVD<dyn_mat<typename Derived::Scalar>> sv(
490 rA, Eigen::DecompositionOptions::ComputeFullU |
491 Eigen::DecompositionOptions::ComputeFullV);
493 return std::make_tuple(sv.matrixU(), sv.singularValues(), sv.matrixV());
503 template <
typename Derived>
514 Eigen::JacobiSVD<dyn_mat<typename Derived::Scalar>> sv(rA);
516 return sv.singularValues();
526 template <
typename Derived>
537 Eigen::JacobiSVD<dyn_mat<typename Derived::Scalar>> sv(
538 rA, Eigen::DecompositionOptions::ComputeFullU);
550 template <
typename Derived>
561 Eigen::JacobiSVD<dyn_mat<typename Derived::Scalar>> sv(
562 rA, Eigen::DecompositionOptions::ComputeFullV);
576 template <
typename Derived>
591 Eigen::ComplexEigenSolver<cmat> es(rA.template cast<cplx>());
594 for (
idx i = 0; i < static_cast<idx>(
evals.rows()); ++i)
608 template <
typename Derived>
623 return funm(rA, &std::sqrt);
632 template <
typename Derived>
656 template <
typename Derived>
671 return funm(rA, &std::exp);
680 template <
typename Derived>
695 return funm(rA, &std::log);
704 template <
typename Derived>
719 return funm(rA, &std::sin);
728 template <
typename Derived>
743 return funm(rA, &std::cos);
757 template <
typename Derived>
773 if (real(z) == 0 && imag(z) == 0)
774 return cmat::Identity(rA.rows(), rA.rows());
776 Eigen::ComplexEigenSolver<cmat> es(rA.template cast<cplx>());
779 for (
idx i = 0; i < static_cast<idx>(
evals.rows()); ++i)
799 template <
typename Derived>
827 for (; n > 0; n /= 2) {
829 result = (result * cA).eval();
830 cA = (cA * cA).eval();
844 template <
typename Derived>
845 double schatten(
const Eigen::MatrixBase<Derived>& A,
double p) {
862 for (
idx i = 0; i < static_cast<idx>(sv.rows()); ++i)
863 result += std::pow(sv[i], p);
865 return std::pow(result, 1. / p);
878 template <
typename OutputScalar,
typename Derived>
879 dyn_mat<OutputScalar>
880 cwise(
const Eigen::MatrixBase<Derived>& A,
881 OutputScalar (*f)(
const typename Derived::Scalar&)) {
894 #pragma omp parallel for collapse(2) 895 #endif // WITH_OPENMP_ 897 for (
idx j = 0; j < static_cast<idx>(rA.cols()); ++j)
898 for (
idx i = 0; i < static_cast<idx>(rA.rows()); ++i)
899 result(i, j) = (*f)(rA(i, j));
916 template <
typename T>
931 template <
typename T,
typename... Args>
945 template <
typename Derived>
952 for (
auto&& elem : As)
958 for (
idx i = 1; i < As.size(); ++i) {
959 result =
kron(result, As[i]);
977 template <
typename Derived>
978 dyn_mat<typename Derived::Scalar>
979 kron(
const std::initializer_list<Derived>& As) {
980 return kron(std::vector<Derived>(As));
992 template <
typename Derived>
1008 std::vector<dyn_mat<typename Derived::Scalar>> As(n, rA);
1025 template <
typename T>
1040 template <
typename T,
typename... Args>
1054 template <
typename Derived>
1061 for (
auto&& elem : As)
1066 idx total_rows = 0, total_cols = 0;
1067 for (
idx i = 0; i < As.size(); ++i) {
1068 total_rows +=
static_cast<idx>(As[i].rows());
1069 total_cols +=
static_cast<idx>(As[i].cols());
1074 idx cur_row = 0, cur_col = 0;
1075 for (
idx i = 0; i < As.size(); ++i) {
1076 result.block(cur_row, cur_col, As[i].rows(), As[i].cols()) = As[i];
1077 cur_row +=
static_cast<idx>(As[i].rows());
1078 cur_col +=
static_cast<idx>(As[i].cols());
1096 template <
typename Derived>
1097 dyn_mat<typename Derived::Scalar>
1098 dirsum(
const std::initializer_list<Derived>& As) {
1099 return dirsum(std::vector<Derived>(As));
1111 template <
typename Derived>
1127 std::vector<dyn_mat<typename Derived::Scalar>> As(n, rA);
1143 template <
typename Derived>
1148 idx Arows =
static_cast<idx>(rA.rows());
1149 idx Acols =
static_cast<idx>(rA.cols());
1157 if (Arows * Acols != rows * cols)
1161 return Eigen::Map<dyn_mat<typename Derived::Scalar>>(
1162 const_cast<typename Derived::Scalar*
>(rA.data()), rows, cols);
1177 template <
typename Derived1,
typename Derived2>
1179 const Eigen::MatrixBase<Derived2>& B) {
1186 if (!std::is_same<
typename Derived1::Scalar,
1187 typename Derived2::Scalar>::value)
1199 if (rA.rows() != rB.rows())
1203 return rA * rB - rB * rA;
1218 template <
typename Derived1,
typename Derived2>
1219 dyn_mat<typename Derived1::Scalar>
1221 const Eigen::MatrixBase<Derived2>& B) {
1228 if (!std::is_same<
typename Derived1::Scalar,
1229 typename Derived2::Scalar>::value)
1241 if (rA.rows() != rB.rows())
1245 return rA * rB + rB * rA;
1257 template <
typename Derived>
1272 double normA =
norm(rA);
1274 return rA *
adjoint(rA) / (normA * normA);
1286 template <
typename Derived>
1294 for (
auto&& elem : As)
1303 for (
auto&& elem : As)
1304 if (elem.rows() != As[0].rows() || elem.cols() != 1)
1314 std::vector<dyn_mat<typename Derived::Scalar>> outvecs;
1317 for (pos = 0; pos < As.size(); ++pos) {
1318 if (
norm(As[pos]) > 0)
1320 outvecs.push_back(As[pos]);
1326 for (
idx i = pos + 1; i < As.size(); ++i) {
1327 cut -=
prj(outvecs[i - 1 - pos]);
1329 outvecs.push_back(vi);
1335 for (
auto&& elem : outvecs) {
1336 double normA =
norm(elem);
1339 result.col(cnt) = elem / normA;
1344 return result.block(0, 0, As[0].rows(), cnt);
1355 template <
typename Derived>
1356 dyn_mat<typename Derived::Scalar>
1357 grams(
const std::initializer_list<Derived>& As) {
1358 return grams(std::vector<Derived>(As));
1368 template <
typename Derived>
1378 std::vector<dyn_mat<typename Derived::Scalar>> input;
1380 for (
idx i = 0; i < static_cast<idx>(rA.cols()); ++i)
1381 input.push_back(rA.col(i));
1383 return grams<dyn_mat<typename Derived::Scalar>>(input);
1402 if (n >= std::accumulate(std::begin(dims), std::end(dims),
1403 static_cast<idx>(1), std::multiplies<idx>()))
1411 return std::vector<idx>(result, result + dims.size());
1425 const std::vector<idx>& dims) {
1431 for (
idx i = 0; i < dims.size(); ++i)
1432 if (midx[i] >= dims[i])
1453 inline ket mket(
const std::vector<idx>& mask,
const std::vector<idx>& dims) {
1454 idx n = mask.size();
1456 idx D = std::accumulate(std::begin(dims), std::end(dims),
1457 static_cast<idx>(1), std::multiplies<idx>());
1468 if (mask.size() != dims.size())
1471 for (
idx i = 0; i < n; ++i)
1472 if (mask[i] >= dims[i])
1476 ket result = ket::Zero(D);
1497 idx n = mask.size();
1498 idx D =
static_cast<idx>(std::llround(std::pow(d, n)));
1511 for (
idx i = 0; i < n; ++i)
1516 ket result = ket::Zero(D);
1517 std::vector<idx> dims(n, d);
1539 inline cmat mprj(
const std::vector<idx>& mask,
const std::vector<idx>& dims) {
1540 idx n = mask.size();
1542 idx D = std::accumulate(std::begin(dims), std::end(dims),
1543 static_cast<idx>(1), std::multiplies<idx>());
1554 if (mask.size() != dims.size())
1557 for (
idx i = 0; i < n; ++i)
1558 if (mask[i] >= dims[i])
1562 cmat result = cmat::Zero(D, D);
1564 result(pos, pos) = 1;
1585 idx n = mask.size();
1586 idx D =
static_cast<idx>(std::llround(std::pow(d, n)));
1599 for (
idx i = 0; i < n; ++i)
1604 cmat result = cmat::Zero(D, D);
1605 std::vector<idx> dims(n, d);
1607 result(pos, pos) = 1;
1620 template <
typename InputIterator>
1621 std::vector<double>
abssq(InputIterator first, InputIterator last) {
1622 std::vector<double> weights(std::distance(first, last));
1623 std::transform(first, last, std::begin(weights),
1635 template <
typename Container>
1646 return abssq(std::begin(c), std::end(c));
1655 template <
typename Derived>
1656 std::vector<double>
abssq(
const Eigen::MatrixBase<Derived>& A) {
1666 return abssq(rA.data(), rA.data() + rA.size());
1677 template <
typename InputIterator>
1678 typename std::iterator_traits<InputIterator>::value_type
1679 sum(InputIterator first, InputIterator last) {
1680 using value_type =
typename std::iterator_traits<InputIterator>::value_type;
1682 return std::accumulate(first, last, static_cast<value_type>(0));
1692 template <
typename Container>
1693 typename Container::value_type
1696 return sum(std::begin(c), std::end(c));
1707 template <
typename InputIterator>
1708 typename std::iterator_traits<InputIterator>::value_type
1709 prod(InputIterator first, InputIterator last) {
1710 using value_type =
typename std::iterator_traits<InputIterator>::value_type;
1712 return std::accumulate(first, last, static_cast<value_type>(1),
1713 std::multiplies<value_type>());
1723 template <
typename Container>
1724 typename Container::value_type
1727 return prod(std::begin(c), std::end(c));
1742 template <
typename Derived>
1743 dyn_col_vect<typename Derived::Scalar>
1762 for (
idx k = 0; k < static_cast<idx>(rA.rows()); ++k) {
1763 if (std::abs(tmp_evals(k)) > 0) {
1764 result = tmp_evects.col(k);
1783 if (n < subsys.size())
1785 for (
idx i = 0; i < subsys.size(); ++i)
1790 std::vector<idx> all(n);
1791 std::vector<idx> subsys_bar(n - subsys.size());
1793 std::iota(std::begin(all), std::end(all), 0);
1794 std::sort(std::begin(subsys), std::end(subsys));
1795 std::set_difference(std::begin(all), std::end(all), std::begin(subsys),
1796 std::end(subsys), std::begin(subsys_bar));
1811 template <
typename Derived>
1812 std::vector<double>
rho2bloch(
const Eigen::MatrixBase<Derived>& A) {
1822 std::vector<double> result(3);
1823 cmat X(2, 2), Y(2, 2), Z(2, 2);
1825 Y << 0, -1_i, 1_i, 0;
1827 result[0] = std::real(
trace(rA * X));
1828 result[1] = std::real(
trace(rA * Y));
1829 result[2] = std::real(
trace(rA * Z));
1848 "r is not a 3-dimensional vector!");
1851 cmat X(2, 2), Y(2, 2), Z(2, 2), Id2(2, 2);
1853 Y << 0, -1_i, 1_i, 0;
1857 return (Id2 + r[0] * X + r[1] * Y + r[2] * Z) / 2.;
1860 inline namespace literals {
1871 template <
char... Bits>
1873 constexpr
idx n =
sizeof...(Bits);
1874 constexpr
char bits[n + 1] = {Bits...,
'\0'};
1875 qpp::ket q = qpp::ket::Zero(std::pow(2, n));
1881 for (
idx i = 0; i < n; ++i) {
1882 if (bits[i] !=
'0' && bits[i] !=
'1')
1887 pos = std::stoi(bits,
nullptr, 2);
1902 template <
char... Bits>
1904 constexpr
idx n =
sizeof...(Bits);
1905 constexpr
char bits[n + 1] = {Bits...,
'\0'};
1906 qpp::bra q = qpp::ket::Zero(std::pow(2, n));
1912 for (
idx i = 0; i < n; ++i) {
1913 if (bits[i] !=
'0' && bits[i] !=
'1')
1918 pos = std::stoi(bits,
nullptr, 2);
1935 template <
char... Bits>
1937 constexpr
idx n =
sizeof...(Bits);
1938 constexpr
char bits[n + 1] = {Bits...,
'\0'};
1943 for (
idx i = 0; i < n; ++i) {
1944 if (bits[i] !=
'0' && bits[i] !=
'1')
1949 return kron(
operator""_ket<Bits...>(),
operator""_bra<Bits...>());
1953 namespace internal {
1958 std::hash<T> hasher;
1959 seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
1972 template <
typename Derived>
1974 std::size_t seed = 0) {
1984 auto* p = rA.data();
1985 idx sizeA =
static_cast<idx>(rA.size());
1986 for (
idx i = 0; i < sizeA; ++i) {
1994 namespace internal {
2000 template <
typename Derived>
2001 std::size_t
operator()(
const Eigen::MatrixBase<Derived>& A)
const {
2014 template <
typename Derived>
2016 const Eigen::MatrixBase<Derived>& B)
const {
2019 if (rA.rows() == rB.rows() && rA.cols() == rB.cols())
2020 return rA == rB ?
true :
false;
bool check_nonzero_size(const T &x) noexcept
Definition: util.h:123
std::pair< dyn_col_vect< double >, cmat > heig(const Eigen::MatrixBase< Derived > &A)
Full eigen decomposition of Hermitian expression.
Definition: functions.h:398
Dimensions not equal exception.
Definition: exception.h:284
Dimension(s) mismatch matrix size exception.
Definition: exception.h:300
Derived::Scalar logdet(const Eigen::MatrixBase< Derived > &A)
Logarithm of the determinant.
Definition: functions.h:174
void hash_combine(std::size_t &seed, const T &v)
Definition: functions.h:1957
constexpr idx maxn
Maximum number of allowed qubits/qudits (subsystems)
Definition: constants.h:67
Matrix is not square nor vector exception.
Definition: exception.h:239
cmat absm(const Eigen::MatrixBase< Derived > &A)
Matrix absolute value.
Definition: functions.h:633
dyn_mat< typename Derived1::Scalar > kron2(const Eigen::MatrixBase< Derived1 > &A, const Eigen::MatrixBase< Derived2 > &B)
Definition: util.h:277
bool check_cvector(const Eigen::MatrixBase< Derived > &A)
Definition: util.h:117
Custom exception.
Definition: exception.h:600
cmat expm(const Eigen::MatrixBase< Derived > &A)
Matrix exponential.
Definition: functions.h:657
Derived::Scalar prod(const Eigen::MatrixBase< Derived > &A)
Element-wise product of A.
Definition: functions.h:228
Eigen::RowVectorXcd bra
Complex (double precision) dynamic Eigen row vector.
Definition: types.h:59
dyn_mat< typename T::Scalar > dirsum(const T &head)
Direct sum.
Definition: functions.h:1026
Functor for hashing Eigen expressions.
Definition: functions.h:1999
Eigen::Matrix< Scalar, Eigen::Dynamic, Eigen::Dynamic > dyn_mat
Dynamic Eigen matrix over the field specified by Scalar.
Definition: types.h:81
idx multiidx2n(const idx *const midx, idx numdims, const idx *const dims) noexcept
Definition: util.h:71
void n2multiidx(idx n, idx numdims, const idx *const dims, idx *result) noexcept
Definition: util.h:43
std::vector< double > rho2bloch(const Eigen::MatrixBase< Derived > &A)
Computes the 3-dimensional real Bloch vector corresponding to the qubit density matrix A...
Definition: functions.h:1812
Subsystems mismatch dimensions exception.
Definition: exception.h:365
Eigen::VectorXcd ket
Complex (double precision) dynamic Eigen column vector.
Definition: types.h:54
dyn_mat< typename Derived1::Scalar > anticomm(const Eigen::MatrixBase< Derived1 > &A, const Eigen::MatrixBase< Derived2 > &B)
Anti-commutator.
Definition: functions.h:1220
Matrix is not a column vector exception.
Definition: exception.h:164
Quantum++ main namespace.
Definition: circuits.h:35
std::pair< dyn_col_vect< cplx >, cmat > eig(const Eigen::MatrixBase< Derived > &A)
Full eigen decomposition.
Definition: functions.h:317
double norm(const Eigen::MatrixBase< Derived > &A)
Frobenius norm.
Definition: functions.h:248
bool check_rvector(const Eigen::MatrixBase< Derived > &A)
Definition: util.h:111
cmat spectralpowm(const Eigen::MatrixBase< Derived > &A, const cplx z)
Matrix power.
Definition: functions.h:758
std::size_t operator()(const Eigen::MatrixBase< Derived > &A) const
Definition: functions.h:2001
dyn_col_vect< double > hevals(const Eigen::MatrixBase< Derived > &A)
Hermitian eigenvalues.
Definition: functions.h:425
dyn_mat< OutputScalar > cwise(const Eigen::MatrixBase< Derived > &A, OutputScalar(*f)(const typename Derived::Scalar &))
Functor.
Definition: functions.h:880
Invalid dimension(s) exception.
Definition: exception.h:269
Checks whether T is compatible with an STL-like iterable container.
Definition: traits.h:71
dyn_col_vect< typename Derived::Scalar > rho2pure(const Eigen::MatrixBase< Derived > &A)
Finds the pure state representation of a matrix proportional to a projector onto a pure state...
Definition: functions.h:1744
dyn_mat< typename Derived::Scalar > dirsumpow(const Eigen::MatrixBase< Derived > &A, idx n)
Direct sum power.
Definition: functions.h:1112
cmat evects(const Eigen::MatrixBase< Derived > &A)
Eigenvectors.
Definition: functions.h:369
cmat funm(const Eigen::MatrixBase< Derived > &A, cplx(*f)(const cplx &))
Functional calculus f(A)
Definition: functions.h:577
double schatten(const Eigen::MatrixBase< Derived > &A, double p)
Schatten matrix norm.
Definition: functions.h:845
cmat svdU(const Eigen::MatrixBase< Derived > &A)
Left singular vectors.
Definition: functions.h:527
cmat bloch2rho(const std::vector< double > &r)
Computes the density matrix corresponding to the 3-dimensional real Bloch vector r.
Definition: functions.h:1842
std::vector< idx > n2multiidx(idx n, const std::vector< idx > &dims)
Non-negative integer index to multi-index.
Definition: functions.h:1396
dyn_mat< typename Derived::Scalar > adjoint(const Eigen::MatrixBase< Derived > &A)
Adjoint.
Definition: functions.h:89
idx multiidx2n(const std::vector< idx > &midx, const std::vector< idx > &dims)
Multi-index to non-negative integer index.
Definition: functions.h:1424
dyn_col_vect< double > svals(const Eigen::MatrixBase< Derived > &A)
Singular values.
Definition: functions.h:504
dyn_mat< typename T::Scalar > kron(const T &head)
Kronecker product.
Definition: functions.h:917
Functor for comparing Eigen expressions for equality.
Definition: functions.h:2013
std::size_t hash_eigen(const Eigen::MatrixBase< Derived > &A, std::size_t seed=0)
Computes the hash of en Eigen matrix/vector/expression.
Definition: functions.h:1973
std::complex< double > cplx
Complex number in double precision.
Definition: types.h:49
cmat mprj(const std::vector< idx > &mask, const std::vector< idx > &dims)
Projector onto multi-partite qudit ket.
Definition: functions.h:1539
Derived::Scalar det(const Eigen::MatrixBase< Derived > &A)
Determinant.
Definition: functions.h:151
dyn_mat< typename Derived::Scalar > transpose(const Eigen::MatrixBase< Derived > &A)
Transpose.
Definition: functions.h:46
dyn_mat< typename Derived::Scalar > kronpow(const Eigen::MatrixBase< Derived > &A, idx n)
Kronecker power.
Definition: functions.h:993
dyn_mat< typename Derived::Scalar > prj(const Eigen::MatrixBase< Derived > &A)
Projector.
Definition: functions.h:1258
dyn_mat< typename Derived::Scalar > powm(const Eigen::MatrixBase< Derived > &A, idx n)
Fast matrix power based on the SQUARE-AND-MULTIPLY algorithm.
Definition: functions.h:800
Type mismatch exception.
Definition: exception.h:530
dyn_col_vect< cplx > evals(const Eigen::MatrixBase< Derived > &A)
Eigenvalues.
Definition: functions.h:344
cmat hevects(const Eigen::MatrixBase< Derived > &A)
Eigenvectors of Hermitian matrix.
Definition: functions.h:450
dyn_mat< typename Derived::Scalar > conjugate(const Eigen::MatrixBase< Derived > &A)
Complex conjugate.
Definition: functions.h:68
constexpr double infty
Used to denote infinity in double precision.
Definition: constants.h:81
bool check_square_mat(const Eigen::MatrixBase< Derived > &A)
Definition: util.h:99
Derived::Scalar trace(const Eigen::MatrixBase< Derived > &A)
Trace.
Definition: functions.h:130
cmat svdV(const Eigen::MatrixBase< Derived > &A)
Right singular vectors.
Definition: functions.h:551
dyn_mat< typename Derived1::Scalar > dirsum2(const Eigen::MatrixBase< Derived1 > &A, const Eigen::MatrixBase< Derived2 > &B)
Definition: util.h:321
cmat cosm(const Eigen::MatrixBase< Derived > &A)
Matrix cos.
Definition: functions.h:729
Argument out of range exception.
Definition: exception.h:515
Eigen::Matrix< Scalar, Eigen::Dynamic, 1 > dyn_col_vect
Dynamic Eigen column vector over the field specified by Scalar.
Definition: types.h:93
cmat sinm(const Eigen::MatrixBase< Derived > &A)
Matrix sin.
Definition: functions.h:705
std::vector< double > abssq(InputIterator first, InputIterator last)
Computes the absolute values squared of an STL-like range of complex numbers.
Definition: functions.h:1621
Matrix is not 2 x 2 exception.
Definition: exception.h:411
dyn_mat< typename Derived::Scalar > grams(const std::vector< Derived > &As)
Gram-Schmidt orthogonalization.
Definition: functions.h:1287
dyn_mat< typename Derived1::Scalar > comm(const Eigen::MatrixBase< Derived1 > &A, const Eigen::MatrixBase< Derived2 > &B)
Commutator.
Definition: functions.h:1178
Eigen::MatrixXcd cmat
Complex (double precision) dynamic Eigen matrix.
Definition: types.h:64
ket mket(const std::vector< idx > &mask, const std::vector< idx > &dims)
Multi-partite qudit ket.
Definition: functions.h:1453
dyn_mat< typename Derived::Scalar > inverse(const Eigen::MatrixBase< Derived > &A)
Inverse.
Definition: functions.h:110
cmat logm(const Eigen::MatrixBase< Derived > &A)
Matrix logarithm.
Definition: functions.h:681
bool check_dims(const std::vector< idx > &dims)
Definition: util.h:134
bool operator()(const Eigen::MatrixBase< Derived > &A, const Eigen::MatrixBase< Derived > &B) const
Definition: functions.h:2015
cmat sqrtm(const Eigen::MatrixBase< Derived > &A)
Matrix square root.
Definition: functions.h:609
std::size_t idx
Non-negative integer index, make sure you use an unsigned type.
Definition: types.h:39
Matrix is not square exception.
Definition: exception.h:149
std::vector< idx > complement(std::vector< idx > subsys, idx n)
Constructs the complement of a subsystem vector.
Definition: functions.h:1780
Derived::Scalar sum(const Eigen::MatrixBase< Derived > &A)
Element-wise sum of A.
Definition: functions.h:207
dyn_mat< typename Derived::Scalar > reshape(const Eigen::MatrixBase< Derived > &A, idx rows, idx cols)
Reshape.
Definition: functions.h:1144
dyn_mat< typename Derived::Scalar > normalize(const Eigen::MatrixBase< Derived > &A)
Normalizes state vector (column or row vector) or density matrix.
Definition: functions.h:270
std::tuple< cmat, dyn_col_vect< double >, cmat > svd(const Eigen::MatrixBase< Derived > &A)
Full singular value decomposition.
Definition: functions.h:479
Object has zero size exception.
Definition: exception.h:134
bool check_qubit_matrix(const Eigen::MatrixBase< Derived > &A) noexcept
Definition: util.h:240