numeric_limits

class numpy::numeric_limits

numpy C++ class.

Example

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

// Use numeric_limits
numeric_limits obj;
// ... operations ...

Statistics

Signature	Return Type	Location	Example
numpy::float16 max()	numpy::float16	NP_FLOAT16.H:304	View
numpy::float16 min()	numpy::float16	NP_FLOAT16.H:303	View

Math Operations

Signature	Return Type	Location	Example
numpy::float16 round_error()	numpy::float16	NP_FLOAT16.H:307

Other Methods

Signature	Return Type	Location	Example
numpy::float16 denorm_min()	numpy::float16	NP_FLOAT16.H:311
numpy::float16 epsilon()	numpy::float16	NP_FLOAT16.H:306	View
numpy::float16 infinity()	numpy::float16	NP_FLOAT16.H:308	View
numpy::float16 lowest()	numpy::float16	NP_FLOAT16.H:305	View
numpy::float16 quiet_NaN()	numpy::float16	NP_FLOAT16.H:309	View
numpy::float16 signaling_NaN()	numpy::float16	NP_FLOAT16.H:310

Code Examples

The following examples are extracted from the test suite.

max (np_test_1_all.cpp:7274)

    if (sizeof(uintp) == sizeof(void*)) {
        // std::cout << "                -> uintp size matches pointer size";
    } else {
        // std::cout << "  ✗ uintp size doesn't match pointer size" << std::endl;
    }

    // Test range limits
    // std::cout << "Range Information:" << std::endl;
    // std::cout << "  intp min: " << std::numeric_limits<intp>::min() << std::endl;
    // std::cout << "  intp max: " << std::numeric_limits<intp>::max() << std::endl;
    // std::cout << "  uintp max: " << std::numeric_limits<uintp>::max() << std::endl;
    // std::cout << "  longdouble digits: " << std::numeric_limits<longdouble>::digits << std::endl;

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

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

    clongdouble c1(3.0L, 4.0L);  // 3 + 4i

min (np_test_1_all.cpp:2350)

        if (i % 3 == 0) {
            large_array.setElementAt({i}, object_(static_cast<int>(i)));
        } else if (i % 3 == 1) {
            large_array.setElementAt({i}, object_(static_cast<double>(i) * 0.5));
        } else {
            large_array.setElementAt({i}, object_(std::string("str") + std::to_string(i)));
        }
    }

    // Verify pattern
    for (size_t i = 0; i < std::min(large_size, size_t(100)); ++i) {  // Check first 100
        object_ obj = large_array.getElementAt({i});
        if (i % 3 == 0) {
            if (!(obj.is_type<int>())) {
                std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<int>())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
        } else if (i % 3 == 1) {
            if (!(obj.is_type<double>())) {
                std::string description = std::string("unknown_function():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<double>())";

epsilon (np_test_1_all.cpp:7822)

    // std::cout << "  float16: " << sizeof(float16) << " bytes" << std::endl;
    // std::cout << "  float32: " << sizeof(float32) << " bytes" << std::endl;
    // std::cout << "  float64: " << sizeof(float64) << " bytes" << std::endl;
    // std::cout << "  float128: " << sizeof(float128) << " bytes" << std::endl;

    // Test numeric limits
    // std::cout << "Numeric limits:" << std::endl;
    // std::cout << "  min: " << std::numeric_limits<float16>::min() << std::endl;
    // std::cout << "  max: " << std::numeric_limits<float16>::max() << std::endl;
    // std::cout << "  lowest: " << std::numeric_limits<float16>::lowest() << std::endl;
    // std::cout << "  epsilon: " << std::numeric_limits<float16>::epsilon() << std::endl;
    // std::cout << "  digits: " << std::numeric_limits<float16>::digits << std::endl;
    // std::cout << "  digits10: " << std::numeric_limits<float16>::digits10 << std::endl;

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

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

    // Test some known bit patterns

infinity (np_test_1_all.cpp:1067)

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

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

    auto arr = createFloat64Array({4});
    arr.setElementAt({0}, 1.0);
    arr.setElementAt({1}, std::numeric_limits<double>::quiet_NaN());
    arr.setElementAt({2}, std::numeric_limits<double>::infinity());
    arr.setElementAt({3}, -std::numeric_limits<double>::infinity());

    auto scalar_arr = createFloat64Array({4});
    scalar_arr.setElementAt({0}, 2.0);
    scalar_arr.setElementAt({1}, 1.0);
    scalar_arr.setElementAt({2}, 1.0);
    scalar_arr.setElementAt({3}, 1.0);

    // Test NaN behavior - NaN comparisons should be false
    auto gt_result = greater(arr, scalar_arr);

lowest (np_test_1_all.cpp:7821)

    // std::cout << "Size comparison:" << std::endl;
    // std::cout << "  float16: " << sizeof(float16) << " bytes" << std::endl;
    // std::cout << "  float32: " << sizeof(float32) << " bytes" << std::endl;
    // std::cout << "  float64: " << sizeof(float64) << " bytes" << std::endl;
    // std::cout << "  float128: " << sizeof(float128) << " bytes" << std::endl;

    // Test numeric limits
    // std::cout << "Numeric limits:" << std::endl;
    // std::cout << "  min: " << std::numeric_limits<float16>::min() << std::endl;
    // std::cout << "  max: " << std::numeric_limits<float16>::max() << std::endl;
    // std::cout << "  lowest: " << std::numeric_limits<float16>::lowest() << std::endl;
    // std::cout << "  epsilon: " << std::numeric_limits<float16>::epsilon() << std::endl;
    // std::cout << "  digits: " << std::numeric_limits<float16>::digits << std::endl;
    // std::cout << "  digits10: " << std::numeric_limits<float16>::digits10 << std::endl;

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

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

quiet_NaN (np_test_1_all.cpp:1066)

    // std::cout << "[OK] equal and not_equal functions" << std::endl;

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

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

    auto arr = createFloat64Array({4});
    arr.setElementAt({0}, 1.0);
    arr.setElementAt({1}, std::numeric_limits<double>::quiet_NaN());
    arr.setElementAt({2}, std::numeric_limits<double>::infinity());
    arr.setElementAt({3}, -std::numeric_limits<double>::infinity());

    auto scalar_arr = createFloat64Array({4});
    scalar_arr.setElementAt({0}, 2.0);
    scalar_arr.setElementAt({1}, 1.0);
    scalar_arr.setElementAt({2}, 1.0);
    scalar_arr.setElementAt({3}, 1.0);

    // Test NaN behavior - NaN comparisons should be false