CategoricalDtype

class numpy::CategoricalDtype

numpy C++ class.

Example

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

// Use CategoricalDtype
CategoricalDtype obj;
// ... operations ...

Constructors

Signature	Location	Example
CategoricalDtype(const std::vector<std::string>& categories, bool ordered = false)	df_categorical_dtype.h:44

Indexing / Selection

Signature	Return Type	Location	Example
const std::string& get_category(int32_t code) const	const std::string&	df_categorical_dtype.h:161
int32_t get_category_code(const std::string& value) const	int32_t	df_categorical_dtype.h:147
size_t itemsize() const override	size_t	df_categorical_dtype.h:71	View

Other Methods

Signature	Return Type	Location	Example
const std::vector<std::string>& categories() const	const std::vector<std::string>&	df_categorical_dtype.h:114
bool has_category(const std::string& value) const	bool	df_categorical_dtype.h:138
std::string kind() const override	std::string	df_categorical_dtype.h:79
std::string name() const override	std::string	df_categorical_dtype.h:57	View
size_t num_categories() const	size_t	df_categorical_dtype.h:129
numpy::DType numpy_dtype() const override	numpy::DType	df_categorical_dtype.h:64
bool ordered() const	bool	df_categorical_dtype.h:122	View
CategoricalDtype() : ordered\_(false)	CategoricalDtype() :	df_categorical_dtype.h:37
std::string repr() const override	std::string	df_categorical_dtype.h:94
const std::type_info& type() const override	const std::type_info&	df_categorical_dtype.h:86	View
CategoricalDtype with_categories(const std::vector<std::string>& new_categories) const	CategoricalDtype	df_categorical_dtype.h:221
CategoricalDtype with_ordered(bool ordered) const	CategoricalDtype	df_categorical_dtype.h:214

Code Examples

The following examples are extracted from the test suite.

itemsize (np_test_2_all.cpp:3540)

      }

      // Test size
      if (!(size(arr) == 24)) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(size(arr) == 24)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

      // Test itemsize
      if (!(itemsize(arr) == sizeof(double))) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(itemsize(arr) == sizeof(double))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }

      // Test nbytes
      if (!(nbytes(arr) == 24 * sizeof(double))) {
          std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(nbytes(arr) == 24 * sizeof(double))";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);

name (np_test_1_all.cpp:24865)

      uint64_t before_restore = rng.next_uint64();
      rng.set_state(state);
      uint64_t after_restore = rng.next_uint64();

      if (before_restore != after_restore) {
        std::cout << "  [FAIL] : in np_test_bitgen_mt19937() : state restore failed";
        throw std::runtime_error("np_test_bitgen_mt19937 failed: state");
      }

      // Test name
      if (rng.name() != "MT19937") {
        std::cout << "  [FAIL] : in np_test_bitgen_mt19937() : incorrect name";
        throw std::runtime_error("np_test_bitgen_mt19937 failed: name");
      }

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

    // ============================================================================
    // PCG64 TESTS
    // ============================================================================

ordered (np_test_2_all.cpp:8640)

          if (indices.size() != n) {
            std::cout << "   IPP large lexsort:                                                                      -> [FAIL]";
            throw std::runtime_error("IPP large lexsort: FAILED - incorrect result size");
          }

          // Verify sorting correctness
          for (size_t i = 1; i < indices.size(); ++i) {
            size_t prev_idx = indices[i - 1];
            size_t curr_idx = indices[i];

            // Check if correctly ordered (second key primary)
            if (keys[1][curr_idx] < keys[1][prev_idx] ||
              (keys[1][curr_idx] == keys[1][prev_idx] && keys[0][curr_idx] < keys[0][prev_idx])) {
              std::cout << "   IPP large lexsort order:                                                                -> [FAIL]";
              throw std::runtime_error("IPP large lexsort: FAILED - incorrect ordering");
            }
          }

          auto duration_us = std::chrono::duration_cast<std::chrono::microseconds>(end - start).count();
          // std::cout << "[OK] IPP large lexsort (" << n << " elements): PASSED in " << duration_us << " μs" << std::endl;
        }

type (np_test_1_all.cpp:2240)

        std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(multi_array.getElementAt({0, 1}).is_type<std::string>())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    if (!(multi_array.getElementAt({0, 2}).is_type<double>())) {
        std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(multi_array.getElementAt({0, 2}).is_type<double>())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }

    // Test 4: Arrays with all same type (homogeneous)
    NDArray<object_> homo_array = createObjectZeros({5});
    for (size_t i = 0; i < 5; ++i) {
        homo_array.setElementAt({i}, object_(static_cast<int>(i * 10)));
    }

    // Verify all are same type
    for (size_t i = 0; i < 5; ++i) {
        object_ obj = homo_array.getElementAt({i});
        if (!(obj.is_type<int>())) {
            std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<int>())";