RealSchurDecomposition

class numpy::RealSchurDecomposition

numpy C++ class.

Example

#include <numpy/np_ndarray.h>
using namespace numpy;

// Use RealSchurDecomposition
RealSchurDecomposition obj;
// ... operations ...

Constructors

Signature	Location	Example
RealSchurDecomposition(size_tn)	NP_LINALG.H:3425

Indexing / Selection

Signature	Return Type	Location	Example
void extract_eigenvalues()	void	NP_LINALG.H:3476
Block2x2<T> get_2x2_block(size_ti)	Block2x2<T>	NP_LINALG.H:3510
std::vector<std::complex<T>> get_block_eigenvalues(size_ti)	std::vector<std::complex<T>>	NP_LINALG.H:3518

Linear Algebra

Signature	Return Type	Location	Example
void detect_2x2_blocks()	void	NP_LINALG.H:3444

I/O

Signature	Return Type	Location	Example
SchurDecomposition<std::complex<T>> to_complex_schur()	SchurDecomposition<std::complex<T>>	NP_LINALG.H:3538

Type Checking

Signature	Return Type	Location	Example
bool is_2x2_block(size_ti)	bool	NP_LINALG.H:3503

Other Methods

Signature	Return Type	Location	Example
void standardize_blocks()	void	NP_LINALG.H:3530
T validate_decomposition(const NDArray<T>&original_matrix)	T	NP_LINALG.H:3573	View
T validate_orthogonality()	T	NP_LINALG.H:3593	View

Code Examples

The following examples are extracted from the test suite.

validate_decomposition (np_test_1_all.cpp:20183)

  class SchurValidator {
  public:
    struct ValidationResult {
      bool passed;
      double max_error;
      double avg_error;
      std::string error_message;
    };

    // Validate A = Q * T * Q^H
    static ValidationResult validate_decomposition(const NDArray<T>& A,
      const SchurDecomposition<T>& schur) {
      ValidationResult result;
      result.passed = false;
      result.max_error = 0.0;
      result.avg_error = 0.0;

      try {
        // Compute Q * T
        auto QT = matmul(schur.Q, schur.T_matrix);

validate_orthogonality (np_test_1_all.cpp:20236)

      }
      catch (const std::exception& e) {
        result.error_message = std::string("Validation failed with exception: ") + e.what();
      }

      return result;
    }

    // Validate that Q is orthogonal/unitary
    static ValidationResult validate_orthogonality(const NDArray<T>& Q) {
      ValidationResult result;
      result.passed = false;
      result.max_error = 0.0;
      result.avg_error = 0.0;

      try {
        NDArray<T> QH = Q.transposeArray();  // Start with transpose
        if constexpr (utils::is_complex_v<T>) {
          QH = utils::conjugate_transpose(Q);  // Override with conjugate transpose if complex
        }