CharArray

class numpy::CharArray

numpy C++ class.

Example

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

// Use CharArray
CharArray obj;
// ... operations ...

Constructors

Signature	Location	Example
CharArray(const std::vector<size_t>&shape)	NP_CHARARRAY.H:54
CharArray(const std::vector<size_t>&shape, const std::string &fill_value)	NP_CHARARRAY.H:57
CharArray(const NDArray<str\_<N>>&array)	NP_CHARARRAY.H:60
CharArray(const CharArray &other)	NP_CHARARRAY.H:64

Operators

Signature	Return Type	Location	Example
CharArray & operator=(const CharArray &other)	CharArray &	NP_CHARARRAY.H:67
std::string operator[](const std::vector<size_t>&indices)	std::string	NP_CHARARRAY.H:84
std::string operator[](size_tindex)	std::string	NP_CHARARRAY.H:93
NDArray<bool> operator==(const CharArray &other)	NDArray<bool>	NP_CHARARRAY.H:391
NDArray<bool> operator!=(const CharArray &other)	NDArray<bool>	NP_CHARARRAY.H:402
CharArray operator+(const CharArray &other)	CharArray	NP_CHARARRAY.H:414
CharArray operator+(const std::string &scalar)	CharArray	NP_CHARARRAY.H:418
CharArray operator\*(size_trepeats)	CharArray	NP_CHARARRAY.H:422

Array Creation

Signature	Return Type	Location	Example
std::string trimmed(const str\_<N>&s)	std::string	NP_CHARARRAY.H:40

Math Operations

Signature	Return Type	Location	Example
CharArray add(const CharArray &other)	CharArray	NP_CHARARRAY.H:104	View
CharArray add(const std::string &scalar)	CharArray	NP_CHARARRAY.H:108	View
CharArray multiply(size_trepeats)	CharArray	NP_CHARARRAY.H:118	View

Other Methods

Signature	Return Type	Location	Example
const NDArray<str\_<N>>& array()	const NDArray<str_<N>>&	NP_CHARARRAY.H:75	View
NDArray<str\_<N>>& array()	NDArray<str_<N>>&	NP_CHARARRAY.H:76	View
CharArray capitalize()	CharArray	NP_CHARARRAY.H:123	View
CharArray lower()	CharArray	NP_CHARARRAY.H:150	View
CharArray lstrip(const std::string &chars = "  \\n\\r\\f\\v")	CharArray	NP_CHARARRAY.H:219	View
size_t ndim()	size_t	NP_CHARARRAY.H:81	View
str\_<N> padded(const std::string &s)	str_<N>	NP_CHARARRAY.H:48
void print()	void	NP_CHARARRAY.H:432	View
CharArray rstrip(const std::string &chars = "  \\n\\r\\f\\v")	CharArray	NP_CHARARRAY.H:235	View
void set(const std::vector<size_t>&indices, const std::string &value)	void	NP_CHARARRAY.H:88	View
void set(size_tindex, const std::string &value)	void	NP_CHARARRAY.H:97	View
const std::vector<size_t>& shape()	const std::vector<size_t>&	NP_CHARARRAY.H:79	View
size_t size()	size_t	NP_CHARARRAY.H:80	View
CharArray strip(const std::string &chars = "   \\n\\r\\f\\v")	CharArray	NP_CHARARRAY.H:198	View
CharArray swapcase()	CharArray	NP_CHARARRAY.H:180	View
CharArray title()	CharArray	NP_CHARARRAY.H:161	View
std::string toString()	std::string	NP_CHARARRAY.H:427	View
CharArray upper()	CharArray	NP_CHARARRAY.H:139	View

Code Examples

The following examples are extracted from the test suite.

add (np_test_1_all.cpp:6410)

void testCharArrayStringOperationsCharArray() {
    std::cout << "========= testStringOperations =======================";

    // Test string concatenation
    std::vector<std::string> words1 = {"Hello", "Good", "Nice"};
    std::vector<std::string> words2 = {" World", " Day", " Work"};

    auto arr1 = array<32>(words1);
    auto arr2 = array<32>(words2);

    auto result = add(arr1, arr2);
    // std::cout << "String concatenation (add):" << std::endl;
    for (size_t i = 0; i < result.size(); ++i) {
        // std::cout << "'" << arr1[i] << "' + '" << arr2[i] << "' = '" << result[i] << "'";
    }

    // Test scalar addition
    auto scalar_result = add(arr1, "!");
    // std::cout << "Scalar concatenation:" << std::endl;
    for (size_t i = 0; i < scalar_result.size(); ++i) {
        // std::cout << "'" << arr1[i] << "' + '!' = '" << scalar_result[i] << "'";

add (np_test_1_all.cpp:6410)

void testCharArrayStringOperationsCharArray() {
    std::cout << "========= testStringOperations =======================";

    // Test string concatenation
    std::vector<std::string> words1 = {"Hello", "Good", "Nice"};
    std::vector<std::string> words2 = {" World", " Day", " Work"};

    auto arr1 = array<32>(words1);
    auto arr2 = array<32>(words2);

    auto result = add(arr1, arr2);
    // std::cout << "String concatenation (add):" << std::endl;
    for (size_t i = 0; i < result.size(); ++i) {
        // std::cout << "'" << arr1[i] << "' + '" << arr2[i] << "' = '" << result[i] << "'";
    }

    // Test scalar addition
    auto scalar_result = add(arr1, "!");
    // std::cout << "Scalar concatenation:" << std::endl;
    for (size_t i = 0; i < scalar_result.size(); ++i) {
        // std::cout << "'" << arr1[i] << "' + '!' = '" << scalar_result[i] << "'";

multiply (np_test_1_all.cpp:6426)

    // Test scalar addition
    auto scalar_result = add(arr1, "!");
    // std::cout << "Scalar concatenation:" << std::endl;
    for (size_t i = 0; i < scalar_result.size(); ++i) {
        // std::cout << "'" << arr1[i] << "' + '!' = '" << scalar_result[i] << "'";
    }

    // Test string multiplication
    std::vector<std::string> patterns = {"Ha", "Ho", "Hi"};
    auto pattern_arr = array<32>(patterns);
    auto repeated = multiply(pattern_arr, 3);
    // std::cout << "String multiplication:" << std::endl;
    for (size_t i = 0; i < repeated.size(); ++i) {
        // std::cout << "'" << pattern_arr[i] << "' * 3 = '" << repeated[i] << "'";
    }

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

void testCaseConversionsCharArray() {
    std::cout << "========= testCaseConversions =======================";

array (np_test_1_all.cpp:243)

    // std::cout << "Min: " << array.minArray() << std::endl;
    // std::cout << "Max: " << array.maxArray() << std::endl;

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

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

    auto range_array = NDArray<int32>::createRange(0, 12, 1);
    // std::cout << "Range array (0-11):" << std::endl;
    //range_array.printArray();

    auto reshaped = range_array.reshapeArray({3, 4});
    // std::cout << "Reshaped to 3x4:";
    //reshaped.printArray();

    auto flattened = reshaped.flattenArray();
    // std::cout << "Flattened:" << std::endl;
    //flattened.printArray();

array (np_test_1_all.cpp:243)

    // std::cout << "Min: " << array.minArray() << std::endl;
    // std::cout << "Max: " << array.maxArray() << std::endl;

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

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

    auto range_array = NDArray<int32>::createRange(0, 12, 1);
    // std::cout << "Range array (0-11):" << std::endl;
    //range_array.printArray();

    auto reshaped = range_array.reshapeArray({3, 4});
    // std::cout << "Reshaped to 3x4:";
    //reshaped.printArray();

    auto flattened = reshaped.flattenArray();
    // std::cout << "Flattened:" << std::endl;
    //flattened.printArray();

capitalize (np_test_1_all.cpp:6461)

    }

    // Test lower case
    auto lower_result = lower(arr);
    // std::cout << "Lower case:" << std::endl;
    for (size_t i = 0; i < lower_result.size(); ++i) {
        // std::cout << "  '" << lower_result[i] << "'";
    }

    // Test capitalize
    auto cap_result = capitalize(arr);
    // std::cout << "Capitalize:" << std::endl;
    for (size_t i = 0; i < cap_result.size(); ++i) {
        // std::cout << "  '" << cap_result[i] << "'";
    }

    // Test title
    auto title_result = title(arr);
    // std::cout << "Title case:" << std::endl;
    for (size_t i = 0; i < title_result.size(); ++i) {
        // std::cout << "  '" << title_result[i] << "'";

lower (np_test_1_all.cpp:6454)

    }

    // Test upper case
    auto upper_result = upper(arr);
    // std::cout << "Upper case:" << std::endl;
    for (size_t i = 0; i < upper_result.size(); ++i) {
        // std::cout << "  '" << upper_result[i] << "'";
    }

    // Test lower case
    auto lower_result = lower(arr);
    // std::cout << "Lower case:" << std::endl;
    for (size_t i = 0; i < lower_result.size(); ++i) {
        // std::cout << "  '" << lower_result[i] << "'";
    }

    // Test capitalize
    auto cap_result = capitalize(arr);
    // std::cout << "Capitalize:" << std::endl;
    for (size_t i = 0; i < cap_result.size(); ++i) {
        // std::cout << "  '" << cap_result[i] << "'";

lstrip (np_test_1_all.cpp:6641)

    }

    // Test strip
    auto stripped = strip(arr);
    // std::cout << "After strip():" << std::endl;
    for (size_t i = 0; i < stripped.size(); ++i) {
        // std::cout << "'" << stripped[i] << "'";
    }

    // Test lstrip
    auto left_stripped = lstrip(arr);
    // std::cout << "After lstrip():" << std::endl;
    for (size_t i = 0; i < left_stripped.size(); ++i) {
        // std::cout << "'" << left_stripped[i] << "'";
    }

    // Test rstrip
    auto right_stripped = rstrip(arr);
    // std::cout << "After rstrip():" << std::endl;
    for (size_t i = 0; i < right_stripped.size(); ++i) {
        // std::cout << "'" << right_stripped[i] << "'";

ndim (np_test_2_all.cpp:3526)

    void testArrayInfo() {
      std::cout << "Testing array information functions...\n";

      // Test basic info functions
      auto arr = createFloat64Array({ 2, 3, 4 });
      for (size_t i = 0; i < arr.getSize(); ++i) {
        arr.setElementAt({ i / 12, (i / 4) % 3, i % 4 }, static_cast<double>(i));
      }

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

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

print (np_test_1_all.cpp:6395)

    std::vector<std::string> strings = {"Alice", "Bob", "Charlie"};
    auto arr2 = array<32>(strings);
    // std::cout << "Created from strings vector:" << std::endl;
    for (size_t i = 0; i < arr2.size(); ++i) {
        // std::cout << "arr2[" << i << "] = '" << arr2[i] << "'";
    }

    // Test 2D array creation
    chararray16 arr_2d({2, 3}, "test");
    // std::cout << "Created 2D chararray16 with shape {2, 3}:";
    // arr_2d.print();

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

void testCharArrayStringOperationsCharArray() {
    std::cout << "========= testStringOperations =======================";

    // Test string concatenation
    std::vector<std::string> words1 = {"Hello", "Good", "Nice"};
    std::vector<std::string> words2 = {" World", " Day", " Work"};

rstrip (np_test_1_all.cpp:6648)

    }

    // Test lstrip
    auto left_stripped = lstrip(arr);
    // std::cout << "After lstrip():" << std::endl;
    for (size_t i = 0; i < left_stripped.size(); ++i) {
        // std::cout << "'" << left_stripped[i] << "'";
    }

    // Test rstrip
    auto right_stripped = rstrip(arr);
    // std::cout << "After rstrip():" << std::endl;
    for (size_t i = 0; i < right_stripped.size(); ++i) {
        // std::cout << "'" << right_stripped[i] << "'";
    }

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

void testStringComparisonCharArray() {
    std::cout << "========= testStringComparison =======================";

set (np_test_1_all.cpp:6747)

    std::cout << "========= testArrayPrinting =======================";

    // Test 1D array printing
    std::vector<std::string> words = {"Hello", "World", "Test"};
    auto arr_1d = array<16>(words);
    // std::cout << "1D CharArray:" << std::endl;
    // arr_1d.print();

    // Test 2D array printing
    chararray16 arr_2d({2, 2}, "test");
    arr_2d.set({0, 0}, "A");
    arr_2d.set({0, 1}, "B");
    arr_2d.set({1, 0}, "C");
    arr_2d.set({1, 1}, "D");

    // std::cout << "2D CharArray:" << std::endl;
    // arr_2d.print();

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

set (np_test_1_all.cpp:6747)

    std::cout << "========= testArrayPrinting =======================";

    // Test 1D array printing
    std::vector<std::string> words = {"Hello", "World", "Test"};
    auto arr_1d = array<16>(words);
    // std::cout << "1D CharArray:" << std::endl;
    // arr_1d.print();

    // Test 2D array printing
    chararray16 arr_2d({2, 2}, "test");
    arr_2d.set({0, 0}, "A");
    arr_2d.set({0, 1}, "B");
    arr_2d.set({1, 0}, "C");
    arr_2d.set({1, 1}, "D");

    // std::cout << "2D CharArray:" << std::endl;
    // arr_2d.print();

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

shape (np_test_1_all.cpp:3751)

    }

    for (size_t j = 0; j < 3; ++j) {
        arr3.setElementAt({0, j}, static_cast<double>((j + 1) * 100));  // [100, 200, 300]
    }

    // Broadcast all arrays together
    std::vector<NDArray<double>> arrays = {arr1, arr2, arr3};
    auto broadcasted = broadcast_arrays(arrays);

    // All should have shape (2, 3)
    for (const auto& arr : broadcasted) {
        if (!((arr.getShape() == std::vector<size_t>{2, 3}))) {
            std::string description = std::string("test_broadcast_arrays():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((arr.getShape() == std::vector<size_t>{2, 3}))";
            std::cout << std::string("[FAIL] ") + description << std::endl;
            throw std::runtime_error(description);
        }
    }

    // Check values
    if (!(broadcasted[0].getElementAt({0, 1}) == 2.0)) {

size (np_test_1_all.cpp:47)

using namespace numpy;
using namespace numpy::benchmark;
using namespace numpy::char_;

// Helper functions for array comparison tests
namespace {
    const double TOLERANCE = 1e-10;

    bool allTrue(const NDArray<bool>& arr) {
        std::vector<size_t> indices(arr.getShape().size(), 0);
        do {
            if (!arr.getElementAt(indices)) {
                return false;
            }
        } while (incrementIndices(indices, arr.getShape()));
        return true;
    }

    bool allFalse(const NDArray<bool>& arr) {
        std::vector<size_t> indices(arr.getShape().size(), 0);

strip (np_test_1_all.cpp:6634)

    std::vector<std::string> padded = {"  hello  ", "\t\tworld\t\t", "   spaces   "};
    auto arr = array<32>(padded);

    // std::cout << "Original padded strings:" << std::endl;
    for (size_t i = 0; i < arr.size(); ++i) {
        // std::cout << "'" << arr[i] << "'";
    }

    // Test strip
    auto stripped = strip(arr);
    // std::cout << "After strip():" << std::endl;
    for (size_t i = 0; i < stripped.size(); ++i) {
        // std::cout << "'" << stripped[i] << "'";
    }

    // Test lstrip
    auto left_stripped = lstrip(arr);
    // std::cout << "After lstrip():" << std::endl;
    for (size_t i = 0; i < left_stripped.size(); ++i) {
        // std::cout << "'" << left_stripped[i] << "'";

swapcase (np_test_5_all.cpp:1434)

      }

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

    void np_test_string_swapcase() {
      std::cout << "========= swapcase formatting =======================";

      std::vector<std::string> strings = { "Hello World", "TEST", "test" };
      auto arr = numpy::char_::array<32>(strings);
      auto result = numpy::char_::swapcase(arr);

      bool passed = (result.size() == arr.size());

      if (!passed) {
        std::cout << "  [FAIL] : in np_test_string_swapcase() : size mismatch";
        throw std::runtime_error("np_test_string_swapcase failed");
      }

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

title (np_test_1_all.cpp:6468)

    }

    // Test capitalize
    auto cap_result = capitalize(arr);
    // std::cout << "Capitalize:" << std::endl;
    for (size_t i = 0; i < cap_result.size(); ++i) {
        // std::cout << "  '" << cap_result[i] << "'";
    }

    // Test title
    auto title_result = title(arr);
    // std::cout << "Title case:" << std::endl;
    for (size_t i = 0; i < title_result.size(); ++i) {
        // std::cout << "  '" << title_result[i] << "'";
    }

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

void testStringTestingCharArray() {
    std::cout << "========= testStringTesting =======================";

toString (np_test_1_all.cpp:6826)

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

    // Test default constructor
    datetime64 default_dt;
    if (!(default_dt.isNaT())) {
        std::string description = std::string("testDatetime64CreationDateTime():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(default_dt.isNaT())";
        std::cout << std::string("[FAIL] ") + description << std::endl;
        throw std::runtime_error(description);
    }
    // std::cout << "Default datetime64 is NaT: " << default_dt.toString() << std::endl;

    // Test value constructor
    datetime64 epoch_day(0, DateTimeUnit::Day);
    // std::cout << "Epoch day: " << epoch_day.toString() << std::endl;

    // Test string constructor
    datetime64 date_from_string("2024-01-15");
    // std::cout << "Date from string '2024-01-15': " << date_from_string.toString() << std::endl;

    datetime64 datetime_from_string("2024-01-15T10:30:45");

upper (np_test_1_all.cpp:6447)

    std::vector<std::string> mixed_case = {"hello world", "GOOD DAY", "Mixed Case"};
    auto arr = array<32>(mixed_case);

    // std::cout << "Original strings:" << std::endl;
    for (size_t i = 0; i < arr.size(); ++i) {
        // std::cout << "  '" << arr[i] << "'";
    }

    // Test upper case
    auto upper_result = upper(arr);
    // std::cout << "Upper case:" << std::endl;
    for (size_t i = 0; i < upper_result.size(); ++i) {
        // std::cout << "  '" << upper_result[i] << "'";
    }

    // Test lower case
    auto lower_result = lower(arr);
    // std::cout << "Lower case:" << std::endl;
    for (size_t i = 0; i < lower_result.size(); ++i) {
        // std::cout << "  '" << lower_result[i] << "'";