HermitePolynomial

class numpy::HermitePolynomial

numpy C++ class.

Example

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

// Use HermitePolynomial
HermitePolynomial obj;
// ... operations ...

Constructors

Signature	Location	Example
HermitePolynomial(const std::vector<T>&coeffs = {T(0)})	NP_SPECIAL_POLYNOMIALS.H:435

Indexing / Selection

Signature	Return Type	Location	Example
std::string get_default_printstyle()	std::string	NP_SPECIAL_POLYNOMIALS.H:539	View
PolynomialPrintOptions get_printoptions()	PolynomialPrintOptions	NP_SPECIAL_POLYNOMIALS.H:547	View

Other Methods

Signature	Return Type	Location	Example
TargetType convert()	TargetType	NP_SPECIAL_POLYNOMIALS.H:553	View
std::pair<NDArray<T>,NDArray<T>> gauss_quadrature(size_tn)	std::pair<NDArray<T>,NDArray<T>>	NP_SPECIAL_POLYNOMIALS.H:512
HermitePolynomial<T> physicist(size_tn)	HermitePolynomial<T>	NP_SPECIAL_POLYNOMIALS.H:440	View
HermitePolynomial<T> probabilist(size_tn)	HermitePolynomial<T>	NP_SPECIAL_POLYNOMIALS.H:476	View
void set_default_printstyle(const std::string &style)	void	NP_SPECIAL_POLYNOMIALS.H:535	View
void set_precision(intprecision)	void	NP_SPECIAL_POLYNOMIALS.H:543
std::string toString_ascii()	std::string	NP_SPECIAL_POLYNOMIALS.H:559
std::string toString_unicode()	std::string	NP_SPECIAL_POLYNOMIALS.H:600

Code Examples

The following examples are extracted from the test suite.

get_default_printstyle (np_test_5_all.cpp:8998)

    // Test 2: Switch to Unicode via static method
    numpy::Polynomial<double>::set_default_printstyle("unicode");
    std::string result2 = p1.toString();
    // std::cout << "Static method Unicode: " << result2 << std::endl;

    if (!verify_contains(result2, "\u00B7", "Static method Unicode")) {
      throw std::runtime_error("Polynomial<T>::set_default_printstyle('unicode') failed");
    }

    // Test 3: Verify Polynomial<T>::get_default_printstyle() static method
    std::string current_style = numpy::Polynomial<double>::get_default_printstyle();
    // std::cout << "Current style via static method: " << current_style << std::endl;

    if (current_style != "unicode") {
      throw std::runtime_error("Polynomial<T>::get_default_printstyle() returned wrong value");
    }

    // Test 4: Verify all polynomial types share the same global print style
    numpy::Chebyshev<double>::set_default_printstyle("ascii");
    numpy::Chebyshev<double> cheb({ 1.0, 2.0 });

get_printoptions (np_test_2_all.cpp:21259)

  namespace numpy_tests_printoptions {

    // ============================================================================
    // BASIC FUNCTIONALITY TESTS
    // ============================================================================

    void np_test_printoptions_basic() {
      std::cout << "========= printoptions: basic get/set ====";

      // Get default options
      auto default_opts = numpy::get_printoptions();

      // Verify defaults
      if (default_opts.precision != 8) {
        std::cout << "  [FAIL] : in np_test_printoptions_basic() : default precision should be 8, got "
          << default_opts.precision << std::endl;
        throw std::runtime_error("np_test_printoptions_basic failed: default precision incorrect");
      }

      if (default_opts.threshold != 1000) {
        std::cout << "  [FAIL] : in np_test_printoptions_basic() : default threshold should be 1000, got "

convert (np_test_5_all.cpp:9049)

      throw std::runtime_error("Static method and global function don't share state");
    }

    // Reset to default ASCII
    numpy::set_default_printstyle("ascii");

    std::cout << " -> tests passed" << std::endl;
  }

  void np_test_toString_polynomial_convert() {
    std::cout << "========= polynomial.convert(): basis conversion (NumPy API) =======================";

    // Test Chebyshev -> Standard conversion (user's example)
    // NumPy: numpy.polynomial.Chebyshev([1,2,3]).convert(kind=np.polynomial.Polynomial)
    // Expected: -2.0 + 2.0 x + 6.0 x**2
    {
      numpy::special::ChebyshevPolynomial<double> cheb({ 1.0, 2.0, 3.0 });
      auto std_poly = cheb.convert<numpy::Polynomial<double>>();

      if (std_poly.coefficients().size() != 3) {
        throw std::runtime_error("Chebyshev conversion: wrong coefficient count");

physicist (np_test_1_all.cpp:23165)

    // This is implicit in the construction but we verify some key properties

    // std::cout << "[OK] Legendre polynomials work correctly" << std::endl;
    std::cout << " -> tests passed" << std::endl;
  }

  void test_hermite_polynomials() {
    std::cout << "========= test_hermite_polynomials =======================";

    // Test physicist's Hermite polynomials
    auto H0 = numpy::special::HermitePolynomial<double>::physicist(0);
    if (!((H0.coefficients() == std::vector<double>{1}))) {
        std::string description = std::string("test_hermite_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((H0.coefficients() == std::vector<double>{1}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    auto H1 = numpy::special::HermitePolynomial<double>::physicist(1);
    if (!((H1.coefficients() == std::vector<double>{0, 2}))) {
        std::string description = std::string("test_hermite_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((H1.coefficients() == std::vector<double>{0, 2}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;

probabilist (np_test_1_all.cpp:23187)

    }

    auto H2 = numpy::special::HermitePolynomial<double>::physicist(2);
    if (!((H2.coefficients() == std::vector<double>{-2, 0, 4}))) {
        std::string description = std::string("test_hermite_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((H2.coefficients() == std::vector<double>{-2, 0, 4}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test probabilist's Hermite polynomials
    auto He0 = numpy::special::HermitePolynomial<double>::probabilist(0);
    if (!((He0.coefficients() == std::vector<double>{1}))) {
        std::string description = std::string("test_hermite_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((He0.coefficients() == std::vector<double>{1}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    auto He1 = numpy::special::HermitePolynomial<double>::probabilist(1);
    if (!((He1.coefficients() == std::vector<double>{0, 1}))) {
        std::string description = std::string("test_hermite_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((He1.coefficients() == std::vector<double>{0, 1}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;

set_default_printstyle (np_test_5_all.cpp:8798)

    std::cout << " -> tests passed" << std::endl;
  }

  // ===========================
  // Polynomial Tests
  // ===========================

  void np_test_toString_polynomial_basic() {
    std::cout << "========= Polynomial toString() basic ============================";

    numpy::set_default_printstyle("ascii");
    numpy::set_polynomial_precision(2);

    numpy::Polynomial<double> p({ 1.0, 2.0, 3.0 });
    std::string result = p.toString();

    // std::cout << "Polynomial: " << result << std::endl;

    verify_not_empty(result, "Polynomial toString()");

    if (!verify_contains(result, "x", "Polynomial")) {