ChebyshevPolynomial

class numpy::ChebyshevPolynomial

numpy C++ class.

Example

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

// Use ChebyshevPolynomial
ChebyshevPolynomial obj;
// ... operations ...

Constructors

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

Indexing / Selection

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

Other Methods

Signature	Return Type	Location	Example
TargetType convert()	TargetType	NP_SPECIAL_POLYNOMIALS.H:149	View
ChebyshevPolynomial<T> interpolate(const NDArray<T>&y)	ChebyshevPolynomial<T>	NP_SPECIAL_POLYNOMIALS.H:104
ChebyshevPolynomial<T> of_first_kind(size_tn)	ChebyshevPolynomial<T>	NP_SPECIAL_POLYNOMIALS.H:24	View
ChebyshevPolynomial<T> of_second_kind(size_tn)	ChebyshevPolynomial<T>	NP_SPECIAL_POLYNOMIALS.H:59
void set_default_printstyle(const std::string &style)	void	NP_SPECIAL_POLYNOMIALS.H:131	View
void set_precision(intprecision)	void	NP_SPECIAL_POLYNOMIALS.H:139
std::string toString_ascii()	std::string	NP_SPECIAL_POLYNOMIALS.H:155
std::string toString_unicode()	std::string	NP_SPECIAL_POLYNOMIALS.H:201

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");

of_first_kind (np_test_1_all.cpp:23076)

    // assert(std::abs(linear_roots[0].imag()) < 1e-10);

    // std::cout << "[OK] Polynomial root finding works correctly" << std::endl;
    std::cout << " -> tests passed" << std::endl;
  }

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

    // Test first few Chebyshev polynomials of the first kind
    auto T0 = numpy::special::ChebyshevPolynomial<double>::of_first_kind(0);
    if (!((T0.coefficients() == std::vector<double>{1}))) {
        std::string description = std::string("test_chebyshev_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((T0.coefficients() == std::vector<double>{1}))";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    auto T1 = numpy::special::ChebyshevPolynomial<double>::of_first_kind(1);
    if (!((T1.coefficients() == std::vector<double>{0, 1}))) {
        std::string description = std::string("test_chebyshev_polynomials():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((T1.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")) {