Eigen-Contrib  5.0.1-dev+master
 
Loading...
Searching...
No Matches
Bccb.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// This Source Code Form is subject to the terms of the Mozilla
5// Public License v. 2.0. If a copy of the MPL was not distributed
6// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
7// SPDX-FileCopyrightText: The Eigen Authors
8// SPDX-License-Identifier: MPL-2.0
9
10// References:
11// [1] P. J. Davis, "Circulant Matrices", Wiley, 1979. Diagonalization of
12// circulant and block circulant matrices by the DFT; the closed-form
13// eigenstructure used by eigenvalues()/eigenvectors(), and the SVD and
14// pseudo-inverse below, follow from it by taking moduli/phases of the
15// eigenvalues.
16// [2] R. H. Chan and X.-Q. Jin, "An Introduction to Iterative Toeplitz
17// Solvers", SIAM, 2007. BCCB matrices are diagonalized by the 2-D DFT
18// F_{n1} (x) F_{n2}; the FFT-based products and solves below, and the use
19// of BCCB operators as preconditioners for two-level Toeplitz (BTTB)
20// systems, follow this reference.
21// [3] G. H. Golub and C. F. Van Loan, "Matrix Computations", 4th ed., Johns
22// Hopkins University Press, 2013, chapter 5.4 (numerical rank conventions).
23// [4] J. J. Dongarra, J. R. Bunch, C. B. Moler and G. W. Stewart, "LINPACK
24// Users' Guide", SIAM, 1979. determinant()'s balanced accumulation follows
25// the convention of its xGEDI routines, which return determinants as a
26// (fraction, exponent) pair to avoid spurious overflow/underflow.
27// [5] P. H. Sterbenz, "Floating-Point Computation", Prentice-Hall, 1974.
28// Scaling by a power of two is exact, the property the balanced
29// accumulation relies on.
30
31#ifndef EIGEN_STRUCTURED_BCCB_H
32#define EIGEN_STRUCTURED_BCCB_H
33
34// IWYU pragma: private
35#include "./InternalHeaderCheck.h"
36
37namespace Eigen {
38
39template <typename Scalar_, int BlockSize_ = Dynamic, int NumBlocks_ = Dynamic>
40class Bccb;
41
42namespace internal {
43
45constexpr int bccb_dim(int a, int b) { return (a == Dynamic || b == Dynamic) ? Dynamic : a * b; }
46
47template <typename Scalar_, int BlockSize_, int NumBlocks_>
48struct traits<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
49 using Scalar = Scalar_;
50 using StorageKind = Dense;
51 using XprKind = MatrixXpr;
52 using StorageIndex = int;
53 static constexpr int RowsAtCompileTime = bccb_dim(BlockSize_, NumBlocks_);
54 static constexpr int ColsAtCompileTime = RowsAtCompileTime;
55 static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
56 static constexpr int MaxColsAtCompileTime = RowsAtCompileTime;
57 // Deliberately no NestByRefBit: transpose(), conjugate() and adjoint() return
58 // owning temporaries, so Product must nest the operator by value for a
59 // delayed-evaluated product expression to keep its left factor alive. The copy
60 // is O(N), negligible against the O(N log N) product evaluation.
61 static constexpr unsigned int Flags = 0;
62};
63
64template <typename Scalar_, int BlockSize_, int NumBlocks_>
65struct evaluator_traits<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
66 using Kind = IndexBased;
67 using Shape = StructuredShape;
68};
69
70} // namespace internal
71
129template <typename Scalar_, int BlockSize_, int NumBlocks_>
130class Bccb : public EigenBase<Bccb<Scalar_, BlockSize_, NumBlocks_>> {
131 enum DenseAssignment { SetAssignment, AddAssignment, SubAssignment };
132
133 public:
134 using Scalar = Scalar_;
135 using RealScalar = typename NumTraits<Scalar>::Real;
136 using StorageIndex = int;
137 using Complex = std::complex<RealScalar>;
138 // The two-level structure keys on the *column-major* flattening of the n2 x n1
139 // generating array and symbol (entry (k2, k1) is flat index k1*n2 + k2), so
140 // every internal 2-D type is pinned to ColMajor explicitly: the semantics must
141 // not change under EIGEN_DEFAULT_TO_ROW_MAJOR. The single-row special case
142 // only satisfies Eigen's rule that 1 x n matrices be row-major; with one row
143 // the two orders coincide.
144 using GeneratorType =
145 Matrix<Scalar, BlockSize_, NumBlocks_, (BlockSize_ == 1 && NumBlocks_ != 1) ? int(RowMajor) : int(ColMajor)>;
147 using ComplexVector = Matrix<Complex, Dynamic, 1>;
148 using RealVector = Matrix<RealScalar, Dynamic, 1>;
151
152 static constexpr int RowsAtCompileTime = internal::bccb_dim(BlockSize_, NumBlocks_);
153 static constexpr int ColsAtCompileTime = RowsAtCompileTime;
154 static constexpr int MaxRowsAtCompileTime = RowsAtCompileTime;
155 static constexpr int MaxColsAtCompileTime = RowsAtCompileTime;
156 static constexpr int SizeAtCompileTime = internal::size_at_compile_time(RowsAtCompileTime, ColsAtCompileTime);
157 static constexpr int MaxSizeAtCompileTime = SizeAtCompileTime;
158 static constexpr bool IsRowMajor = false;
159 // Deliberately no IsVectorAtCompileTime: Ref<const Bccb>'s default StrideType
160 // argument reads it, so its absence makes internal::is_ref_compatible SFINAE to
161 // false and keeps the iterative solvers on their matrix-free path.
162
170 template <typename Derived>
171 explicit Bccb(const MatrixBase<Derived>& generator) : m_g(generator) {
172 EIGEN_INTERNAL_ASSERT_NONEMPTY_MSG(m_g, "Bccb generator must be non-empty");
173 if (m_g.size() > internal::structured_direct_threshold()) {
174 m_symbol = computeSymbol();
175 m_prodSymbol = computeProdSymbol(m_g);
176 }
177 }
178
179 EIGEN_DEVICE_FUNC Index rows() const { return m_g.size(); }
180 EIGEN_DEVICE_FUNC Index cols() const { return m_g.size(); }
181
183 Index blockSize() const { return m_g.rows(); }
185 Index numBlocks() const { return m_g.cols(); }
187 const GeneratorType& generator() const { return m_g; }
188
194 ComplexArray symbol() const { return m_symbol.size() > 0 ? m_symbol : computeSymbol(); }
195
197 Scalar coeff(Index row, Index col) const {
198 const Index n2 = blockSize();
199 Index k2 = row % n2 - col % n2;
200 if (k2 < 0) k2 += n2;
201 Index k1 = row / n2 - col / n2;
202 if (k1 < 0) k1 += numBlocks();
203 return m_g.coeff(k2, k1);
204 }
205
212 Bccb transpose() const { return Bccb(reverse2(m_g), reverse2(m_symbol), reverse2(m_prodSymbol)); }
213
217 Bccb conjugate() const {
218 return Bccb(m_g.conjugate(), reverse2(m_symbol).conjugate(), reverse2(m_prodSymbol).conjugate());
219 }
220
225 Bccb adjoint() const { return Bccb(reverse2(m_g).conjugate(), m_symbol.conjugate(), m_prodSymbol.conjugate()); }
226
233 template <typename Rhs>
235 EIGEN_INTERNAL_ASSERT_SOLVER_RHS_MSG(*this, b, false, "right-hand side has the wrong number of rows");
236 const Index N = rows();
237 const ComplexArray s = symbol();
238 const RealArray mods = s.cwiseAbs();
239 const ComplexArray sinv = internal::structured_pinv_symbol(s, mods, internal::structured_rank_threshold(s, mods));
241 applySymbol(x, sinv, b.derived(), Scalar(1), /*accumulate=*/false);
242 return x;
243 }
244
251 Index rank() const {
252 const ComplexArray s = symbol();
253 const RealArray mods = s.cwiseAbs();
254 return (!(mods.array() < internal::structured_rank_threshold(s, mods))).count(); // NaN entries count as non-zero
255 }
256
261 Bccb inverse() const {
262 ComplexArray sinv = symbol().cwiseInverse();
263 const GeneratorType ginv = generatorFromSymbol(sinv);
264 const bool cache = rows() > internal::structured_direct_threshold();
265 return Bccb(ginv, cache ? sinv : ComplexArray(), cache ? computeProdSymbol(ginv) : ComplexArray());
266 }
267
276 Scalar determinant() const {
277 const ComplexArray s = symbol();
278 Complex det(1);
279 Index exponent = 0;
280 for (Index k1 = 0; k1 < s.cols(); ++k1)
281 for (Index k2 = 0; k2 < s.rows(); ++k2)
282 det = internal::balance_exponent(Complex(det * internal::balance_exponent(s(k2, k1), exponent)), exponent);
283 return toScalar(internal::apply_exponent(det, exponent), std::is_same<RealScalar, Scalar>());
284 }
285
291 ComplexVector eigenvalues() const { return symbol().reshaped(); }
292
297 ComplexMatrix eigenvectors() const {
298 const Index n2 = blockSize(), n1 = numBlocks(), N = rows();
299 ComplexMatrix F(N, N);
300 for (Index f1 = 0; f1 < n1; ++f1)
301 for (Index f2 = 0; f2 < n2; ++f2) fourierColumn(F, f1, f2, f1 * n2 + f2);
302 return F;
303 }
304
308 RealVector singularValues() const {
309 const ComplexVector s = eigenvalues();
310 const RealVector mods = s.cwiseAbs();
311 const std::vector<Index> perm = internal::structured_svd_permutation(mods);
312 RealVector sv(s.size());
313 for (Index t = 0; t < s.size(); ++t) sv[t] = mods[perm[t]];
314 return sv;
315 }
316
320 ComplexMatrix matrixU() const {
321 const Index n2 = blockSize(), N = rows();
322 const ComplexVector s = eigenvalues();
323 const RealVector mods = s.cwiseAbs();
324 const std::vector<Index> perm = internal::structured_svd_permutation(mods);
325 ComplexMatrix U(N, N);
326 for (Index t = 0; t < N; ++t) {
327 fourierColumn(U, perm[t] / n2, perm[t] % n2, t);
328 const RealScalar a = mods[perm[t]];
329 if (a > RealScalar(0)) U.col(t) *= s[perm[t]] / a;
330 }
331 return U;
332 }
333
337 ComplexMatrix matrixV() const {
338 const Index n2 = blockSize(), N = rows();
339 const ComplexVector s = eigenvalues();
340 const std::vector<Index> perm = internal::structured_svd_permutation(RealVector(s.cwiseAbs()));
341 ComplexMatrix V(N, N);
342 for (Index t = 0; t < N; ++t) fourierColumn(V, perm[t] / n2, perm[t] % n2, t);
343 return V;
344 }
345
350 template <typename Dest>
351 void evalTo(Dest& dst) const {
352 assignTo<SetAssignment>(dst);
353 }
354
356 template <typename Dest>
357 void addTo(Dest& dst) const {
358 assignTo<AddAssignment>(dst);
359 }
360
362 template <typename Dest>
363 void subTo(Dest& dst) const {
364 assignTo<SubAssignment>(dst);
365 }
366
372 template <typename Rhs>
374 return Product<Bccb, Rhs>(*this, x.derived());
375 }
376
380 template <typename Dest, typename Rhs, typename ProductScalar>
381 void addProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
382 const Index N = rows();
383 EIGEN_INTERNAL_ASSERT_PRODUCT_SHAPE_MSG(*this, rhs, "invalid product: dimensions do not match");
384 if (N <= internal::structured_direct_threshold()) {
385 directProduct(dst, rhs, alpha);
386 return;
387 }
388 // Products use the padded embedding symbol when a block dimension is not
389 // 5-smooth (see computeProdSymbol()); the exact-size transform of such a
390 // dimension runs through kissfft's quadratic generic butterfly.
391 const ComplexArray& s = m_prodSymbol.size() > 0 ? m_prodSymbol : m_symbol;
392 applySymbol(dst, s, rhs, alpha, /*accumulate=*/true);
393 }
394
395 private:
398 template <DenseAssignment Assignment, typename Dest>
399 void assignTo(Dest& dst) const {
400 const Index n2 = blockSize(), n1 = numBlocks();
401 for (Index c1 = 0; c1 < n1; ++c1)
402 for (Index j2 = 0; j2 < n2; ++j2) {
403 auto col = dst.col(c1 * n2 + j2);
404 for (Index b1 = 0; b1 < n1; ++b1) {
405 Index k1 = b1 - c1;
406 if (k1 < 0) k1 += n1;
407 EIGEN_IF_CONSTEXPR (Assignment == SetAssignment) {
408 col.segment(b1 * n2, j2) = m_g.col(k1).tail(j2);
409 col.segment(b1 * n2 + j2, n2 - j2) = m_g.col(k1).head(n2 - j2);
410 } else EIGEN_IF_CONSTEXPR (Assignment == AddAssignment) {
411 col.segment(b1 * n2, j2) += m_g.col(k1).tail(j2);
412 col.segment(b1 * n2 + j2, n2 - j2) += m_g.col(k1).head(n2 - j2);
413 } else {
414 col.segment(b1 * n2, j2) -= m_g.col(k1).tail(j2);
415 col.segment(b1 * n2 + j2, n2 - j2) -= m_g.col(k1).head(n2 - j2);
416 }
417 }
418 }
419 }
420
427 Bccb(const GeneratorType& g, const ComplexArray& symbol, const ComplexArray& prodSymbol)
428 : m_g(g), m_symbol(symbol), m_prodSymbol(prodSymbol) {}
429
448 ComplexArray computeProdSymbol(const GeneratorType& g) const {
449 const Index n2 = g.rows(), n1 = g.cols();
450 const Index p2 = internal::fft_next_good_size(n2) == n2 ? n2 : internal::fft_next_good_size(2 * n2 - 1);
451 const Index p1 = internal::fft_next_good_size(n1) == n1 ? n1 : internal::fft_next_good_size(2 * n1 - 1);
452 if (p2 == n2 && p1 == n1) return ComplexArray();
453 ComplexArray Ge = ComplexArray::Zero(p2, p1);
454 Ge.topLeftCorner(n2, n1) = g.template cast<Complex>();
455 if (p2 != n2) Ge.bottomLeftCorner(n2 - 1, n1) = g.bottomRows(n2 - 1).template cast<Complex>();
456 if (p1 != n1) Ge.topRightCorner(n2, n1 - 1) = g.rightCols(n1 - 1).template cast<Complex>();
457 if (p2 != n2 && p1 != n1)
458 Ge.bottomRightCorner(n2 - 1, n1 - 1) = g.bottomRightCorner(n2 - 1, n1 - 1).template cast<Complex>();
459 fft2(Ge);
460 return Ge;
461 }
462
468 template <typename Dest, typename Rhs, typename ProductScalar>
469 void directProductColumn(Dest& dst, const Rhs& rhs, Index k, const ProductScalar& alpha) const {
470 const Index N = rows();
471 // A unit alpha must not multiply: even the identity complex scalar (1,0)
472 // pollutes an (Inf,0) value with NaN through the 0*Inf cross term.
473 const bool unitAlpha = alpha == ProductScalar(1);
474 for (Index i = 0; i < N; ++i) {
475 ProductScalar acc(0);
476 for (Index j = 0; j < N; ++j) acc += coeff(i, j) * rhs.coeff(j, k);
477 dst.coeffRef(i, k) += unitAlpha ? acc : ProductScalar(alpha * acc);
478 }
479 }
480
483 template <typename Dest, typename Rhs, typename ProductScalar>
484 void directProduct(Dest& dst, const Rhs& rhs, const ProductScalar& alpha) const {
485 for (Index k = 0; k < rhs.cols(); ++k) directProductColumn(dst, rhs, k, alpha);
486 }
487
497 template <typename Dest, typename Rhs, typename ProductScalar>
498 void applySymbol(Dest& dst, const ComplexArray& s, const Rhs& rhs, const ProductScalar& alpha,
499 bool accumulate) const {
500 const Index n2 = blockSize(), n1 = numBlocks();
501 const Index p2 = s.rows(), p1 = s.cols(); // the symbol's transform grid: (n2, n1) or the padded product grid
502 const bool padded = p2 != n2 || p1 != n1;
503 ComplexVector xc(rows());
504 ComplexArray X(p2, p1), Xn; // Xn: the leading-block extraction of a padded grid
505 for (Index k = 0; k < rhs.cols(); ++k) {
506 // reshaped() defaults to column-major traversal, the flattening the
507 // two-level structure keys on, regardless of EIGEN_DEFAULT_TO_ROW_MAJOR.
508 // Plain objects keep both reshapes linear.
509 xc = rhs.col(k).template cast<Complex>();
510 if (padded) {
511 X.setZero();
512 X.topLeftCorner(n2, n1) = xc.reshaped(n2, n1);
513 } else {
514 X = xc.reshaped(n2, n1);
515 }
516 fft2(X);
517 X.array() *= s.array();
518 ifft2(X);
519 if (padded) Xn = X.topLeftCorner(n2, n1);
520 const auto out = internal::structured_scalar_part_impl<ProductScalar>::run((padded ? Xn : X).reshaped());
521 if (accumulate)
522 dst.col(k) += alpha * out;
523 else
524 dst.col(k) = alpha * out;
525 }
526 }
527
532 template <bool Inverse>
533 void transform2(ComplexArray& X) const {
534 auto&& fft = internal::structured_fft_engine<RealScalar>();
535 const Index n2 = X.rows(), n1 = X.cols();
536 // Both passes share one output buffer (resized by the engine) and one packed
537 // input buffer, allocated at most twice for the whole transform. A column of
538 // the column-major grid is already packed and goes to the engine as is; a row
539 // is strided, and the engine would pack it into a fresh temporary per call.
540 ComplexVector tmp, rowv;
541 if (n2 > 1) {
542 for (Index k1 = 0; k1 < n1; ++k1) {
543 EIGEN_IF_CONSTEXPR (Inverse) {
544 fft.inv(tmp, X.col(k1), n2);
545 } else {
546 fft.fwd(tmp, X.col(k1), n2);
547 }
548 X.col(k1) = tmp;
549 }
550 }
551 if (n1 > 1) {
552 for (Index k2 = 0; k2 < n2; ++k2) {
553 rowv = X.row(k2).transpose();
554 EIGEN_IF_CONSTEXPR (Inverse) {
555 fft.inv(tmp, rowv, n1);
556 } else {
557 fft.fwd(tmp, rowv, n1);
558 }
559 X.row(k2) = tmp.transpose();
560 }
561 }
562 }
563
565 void fft2(ComplexArray& X) const { transform2<false>(X); }
566
568 void ifft2(ComplexArray& X) const { transform2<true>(X); }
569
571 GeneratorType generatorFromSymbol(ComplexArray symbol) const {
572 ifft2(symbol);
573 GeneratorType generator = internal::structured_scalar_part_impl<Scalar>::run(symbol);
574 return generator;
575 }
576
578 ComplexArray computeSymbol() const {
579 ComplexArray s = m_g.template cast<Complex>();
580 fft2(s);
581 return s;
582 }
583
587 template <typename MatType>
588 static MatType reverse2(const MatType& M) {
589 const Index r = M.rows(), c = M.cols();
590 MatType R(r, c);
591 if (M.size() == 0) return R;
592 R(0, 0) = M(0, 0);
593 if (c > 1) R.row(0).tail(c - 1) = M.row(0).tail(c - 1).reverse();
594 if (r > 1) R.col(0).tail(r - 1) = M.col(0).tail(r - 1).reverse();
595 if (r > 1 && c > 1) R.bottomRightCorner(r - 1, c - 1) = M.bottomRightCorner(r - 1, c - 1).reverse();
596 return R;
597 }
598
604 void fourierColumn(ComplexMatrix& F, Index f1, Index f2, Index dstCol) const {
605 const Index n2 = blockSize(), n1 = numBlocks();
606 const RealScalar scale = RealScalar(1) / numext::sqrt(RealScalar(rows()));
607 ComplexVector w2(n2);
608 Index jf = 0; // i2 * f2 mod n2
609 for (Index i2 = 0; i2 < n2; ++i2) {
610 w2[i2] = std::polar(scale, RealScalar(2 * EIGEN_PI) * RealScalar(jf) / RealScalar(n2));
611 jf += f2;
612 if (jf >= n2) jf -= n2;
613 }
614 Index bf = 0; // b1 * f1 mod n1
615 for (Index b1 = 0; b1 < n1; ++b1) {
616 const Complex w1 = std::polar(RealScalar(1), RealScalar(2 * EIGEN_PI) * RealScalar(bf) / RealScalar(n1));
617 F.col(dstCol).segment(b1 * n2, n2) = w1 * w2;
618 bf += f1;
619 if (bf >= n1) bf -= n1;
620 }
621 }
622
624 static Scalar toScalar(const Complex& z, std::true_type /*scalar_is_real*/) { return numext::real(z); }
625 static Scalar toScalar(const Complex& z, std::false_type /*scalar_is_real*/) { return z; }
626
627 GeneratorType m_g;
628 ComplexArray m_symbol;
629 // The padded embedding symbol products use when a block dimension is not
630 // 5-smooth; empty otherwise. See computeProdSymbol().
631 ComplexArray m_prodSymbol;
632};
633
637template <typename Derived>
642
643namespace internal {
644
645template <typename Scalar_, int BlockSize_, int NumBlocks_, typename Rhs, int ProductTag>
646struct generic_product_impl<Bccb<Scalar_, BlockSize_, NumBlocks_>, Rhs, StructuredShape, DenseShape, ProductTag>
647 : structured_product_impl<Bccb<Scalar_, BlockSize_, NumBlocks_>, Rhs> {};
648
649} // namespace internal
650
651#if EIGEN_COMP_CXXVER < 17
652template <typename Scalar_, int BlockSize_, int NumBlocks_>
653constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::RowsAtCompileTime;
654template <typename Scalar_, int BlockSize_, int NumBlocks_>
655constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::ColsAtCompileTime;
656template <typename Scalar_, int BlockSize_, int NumBlocks_>
657constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::MaxRowsAtCompileTime;
658template <typename Scalar_, int BlockSize_, int NumBlocks_>
659constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::MaxColsAtCompileTime;
660template <typename Scalar_, int BlockSize_, int NumBlocks_>
661constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::SizeAtCompileTime;
662template <typename Scalar_, int BlockSize_, int NumBlocks_>
663constexpr int Bccb<Scalar_, BlockSize_, NumBlocks_>::MaxSizeAtCompileTime;
664template <typename Scalar_, int BlockSize_, int NumBlocks_>
665constexpr bool Bccb<Scalar_, BlockSize_, NumBlocks_>::IsRowMajor;
666#endif
667
668} // namespace Eigen
669
670#endif // EIGEN_STRUCTURED_BCCB_H
A block circulant matrix with circulant blocks (BCCB), the matrix of a two-dimensional circular convo...
Definition Bccb.h:130
ComplexVector eigenvalues() const
Definition Bccb.h:291
Matrix< Scalar, RowsAtCompileTime, Rhs::ColsAtCompileTime > solve(const MatrixBase< Rhs > &b) const
Definition Bccb.h:234
ComplexMatrix eigenvectors() const
Definition Bccb.h:297
Index numBlocks() const
Definition Bccb.h:185
Scalar coeff(Index row, Index col) const
Definition Bccb.h:197
Index blockSize() const
Definition Bccb.h:183
Bccb transpose() const
Definition Bccb.h:212
ComplexMatrix matrixU() const
Definition Bccb.h:320
Index rank() const
Definition Bccb.h:251
Product< Bccb, Rhs > operator*(const MatrixBase< Rhs > &x) const
Definition Bccb.h:373
Bccb conjugate() const
Definition Bccb.h:217
Bccb adjoint() const
Definition Bccb.h:225
ComplexMatrix matrixV() const
Definition Bccb.h:337
Bccb(const MatrixBase< Derived > &generator)
Definition Bccb.h:171
const GeneratorType & generator() const
Definition Bccb.h:187
RealVector singularValues() const
Definition Bccb.h:308
Bccb inverse() const
Definition Bccb.h:261
Scalar determinant() const
Definition Bccb.h:276
ComplexArray symbol() const
Definition Bccb.h:194
Bccb< typename Derived::Scalar, Derived::RowsAtCompileTime, Derived::ColsAtCompileTime > makeBccb(const MatrixBase< Derived > &generator)
Definition Bccb.h:638
Namespace containing all symbols from the Eigen library.