DatetimeIndex#
-
class numpy::DatetimeIndex#
numpy C++ class.
Example#
#include <numpy/np_ndarray.h>
using namespace numpy;
// Use DatetimeIndex
DatetimeIndex obj;
// ... operations ...
Constructors#
Signature |
Location |
Example |
|---|---|---|
|
df_datetime_index.h:96 |
|
|
df_datetime_index.h:106 |
|
|
df_datetime_index.h:116 |
|
|
df_datetime_index.h:134 |
|
|
df_datetime_index.h:145 |
|
|
df_datetime_index.h:152 |
Indexing / Selection#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1137 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1179 |
|
|
df_datetime_index.h:1211 |
||
|
DatetimeIndex |
df_datetime_index.h:2153 |
|
|
DatetimeIndex |
df_datetime_index.h:2169 |
|
|
int64_t |
df_datetime_index.h:1269 |
|
|
std::vector<std::optional<std::string>> |
df_datetime_index.h:2717 |
|
|
size_t |
df_datetime_index.h:1289 |
|
|
numpy::datetime64 |
df_datetime_index.h:1608 |
|
|
DatetimeIndex |
df_datetime_index.h:1711 |
|
|
size_t |
df_datetime_index.h:1774 |
|
|
DatetimeIndex |
df_datetime_index.h:1925 |
|
|
DatetimeIndex |
df_datetime_index.h:2094 |
Shape Manipulation#
Statistics#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
std::optional<numpy::datetime64> |
df_datetime_index.h:336 |
|
|
std::optional<numpy::datetime64> |
df_datetime_index.h:305 |
|
|
std::optional<numpy::timedelta64> |
df_datetime_index.h:415 |
Sorting#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:601 |
|
|
DatetimeIndex |
df_datetime_index.h:1847 |
|
|
DatetimeIndex |
df_datetime_index.h:1857 |
|
|
DatetimeArray |
df_datetime_index.h:2609 |
|
|
std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>> |
df_datetime_index.h:2543 |
Math Operations#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
DatetimeIndex |
df_datetime_index.h:230 |
|
|
DatetimeIndex |
df_datetime_index.h:220 |
|
|
DatetimeIndex |
df_datetime_index.h:210 |
Linear Algebra#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
DatetimeIndex |
df_datetime_index.h:271 |
Comparison#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
bool |
df_datetime_index.h:1039 |
Logical#
Set Operations#
I/O#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
DatetimeIndex |
df_datetime_index.h:1947 |
|
|
std::vector<std::optional<numpy::datetime64>> |
df_datetime_index.h:1963 |
|
|
numpy::NDArray<numpy::datetime64> |
df_datetime_index.h:2629 |
|
|
df_datetime_index.h:2684 |
||
|
std::string |
df_datetime_index.h:493 |
|
|
std::vector<std::optional<numpy::datetime64>> |
df_datetime_index.h:1977 |
Joining / Splitting#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
DatetimeIndex |
df_datetime_index.h:579 |
|
|
DatetimeIndex |
df_datetime_index.h:716 |
|
|
DatetimeIndex |
df_datetime_index.h:740 |
|
|
DatetimeIndex |
df_datetime_index.h:1434 |
|
|
DatetimeIndex |
df_datetime_index.h:1753 |
Type Handling#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:695 |
|
|
DatetimeIndex |
df_datetime_index.h:469 |
|
|
numpy::NDArray<numpy::datetime64> |
df_datetime_index.h:2084 |
Type Checking#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
bool |
df_datetime_index.h:1498 |
|
|
bool |
df_datetime_index.h:1506 |
|
|
bool |
df_datetime_index.h:1514 |
|
|
bool |
df_datetime_index.h:1522 |
|
|
bool |
df_datetime_index.h:1530 |
|
|
bool |
df_datetime_index.h:1538 |
|
|
bool |
df_datetime_index.h:1546 |
|
|
bool |
df_datetime_index.h:1554 |
Other Methods#
Signature |
Return Type |
Location |
Example |
|---|---|---|---|
|
int64_t |
df_datetime_index.h:390 |
|
|
int64_t |
df_datetime_index.h:366 |
|
|
DatetimeArray |
df_datetime_index.h:125 |
|
|
DatetimeArray |
df_datetime_index.h:138 |
|
|
DatetimeIndex |
df_datetime_index.h:250 |
|
|
std::optional<numpy::datetime64> |
df_datetime_index.h:632 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:662 |
|
|
std::unique_ptr<IndexBase> |
df_datetime_index.h:460 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1093 |
|
|
TimedeltaArray |
df_datetime_index.h:760 |
|
|
DatetimeIndex |
df_datetime_index.h:806 |
|
|
DatetimeIndex |
df_datetime_index.h:837 |
|
|
DatetimeIndex |
df_datetime_index.h:865 |
|
|
DatetimeIndex |
df_datetime_index.h:2136 |
|
|
DatetimeIndex |
df_datetime_index.h:921 |
|
|
std::string |
df_datetime_index.h:192 |
|
|
BooleanArray |
df_datetime_index.h:943 |
|
|
std::pair<numpy::NDArray<numpy::int64>, DatetimeIndex> |
df_datetime_index.h:1063 |
|
|
DatetimeIndex |
df_datetime_index.h:1107 |
|
|
std::vector<std::string> |
df_datetime_index.h:1128 |
|
|
std::unordered_map<GroupT, std::vector<size_t>> |
df_datetime_index.h:2200 |
|
|
bool |
df_datetime_index.h:1318 |
|
|
bool |
df_datetime_index.h:1327 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:2429 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:2602 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1251 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1337 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1377 |
|
|
DatetimeIndex |
df_datetime_index.h:2223 |
|
|
std::string |
df_datetime_index.h:184 |
|
|
DatetimeIndex |
df_datetime_index.h:1462 |
|
|
numpy::NDArray<numpy::bool_> |
df_datetime_index.h:1587 |
|
|
numpy::NDArray<numpy::bool_> |
df_datetime_index.h:1600 |
|
|
df_datetime_index.h:2245 |
||
|
DatetimeArray |
df_datetime_index.h:2387 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:2391 |
|
|
DatetimeIndex |
df_datetime_index.h:1625 |
|
|
size_t |
df_datetime_index.h:1651 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:1256 |
|
|
DatetimeArray |
df_datetime_index.h:593 |
|
|
DatetimeArray |
df_datetime_index.h:731 |
|
|
DatetimeArray |
df_datetime_index.h:751 |
|
|
DatetimeArray |
df_datetime_index.h:828 |
|
|
DatetimeArray |
df_datetime_index.h:856 |
|
|
DatetimeArray |
df_datetime_index.h:913 |
|
|
DatetimeArray |
df_datetime_index.h:934 |
|
|
DatetimeArray |
df_datetime_index.h:1119 |
|
|
DatetimeArray |
df_datetime_index.h:1453 |
|
|
DatetimeArray |
df_datetime_index.h:1489 |
|
|
DatetimeArray |
df_datetime_index.h:1642 |
|
|
DatetimeArray |
df_datetime_index.h:1724 |
|
|
DatetimeArray |
df_datetime_index.h:1764 |
|
|
DatetimeArray |
df_datetime_index.h:1916 |
|
|
DatetimeArray |
df_datetime_index.h:1939 |
|
|
DatetimeArray |
df_datetime_index.h:2036 |
|
|
DatetimeArray |
df_datetime_index.h:2107 |
|
|
size_t |
df_datetime_index.h:2709 |
|
|
numpy::NDArray<numpy::bool_> |
df_datetime_index.h:1660 |
|
|
numpy::NDArray<numpy::bool_> |
df_datetime_index.h:1673 |
|
|
size_t |
df_datetime_index.h:1682 |
|
|
std::pair<DatetimeIndex, numpy::NDArray<numpy::int64>> |
df_datetime_index.h:2424 |
|
|
DatetimeIndex |
df_datetime_index.h:481 |
|
|
std::string |
df_datetime_index.h:534 |
|
|
numpy::NDArray<numpy::int64> |
df_datetime_index.h:2392 |
|
|
DatetimeIndex |
df_datetime_index.h:1804 |
|
|
DatetimeIndex |
df_datetime_index.h:261 |
|
|
std::pair<size_t, size_t> |
df_datetime_index.h:1816 |
|
|
std::pair<size_t, size_t> |
df_datetime_index.h:1837 |
|
|
DatetimeIndex |
df_datetime_index.h:240 |
|
|
DatetimeIndex |
df_datetime_index.h:1881 |
|
|
DatetimeIndex |
df_datetime_index.h:291 |
|
|
DatetimeIndex |
df_datetime_index.h:281 |
|
|
DatetimeIndex |
df_datetime_index.h:1994 |
|
|
std::unordered_map<int64_t, size_t> |
df_datetime_index.h:2055 |
Code Examples#
The following examples are extracted from the test suite.
get_names (np_test_1_all.cpp:21728)
21718 RecordArray base(dtype, { 2 });
21719 base.setFieldValue({ 0 }, "name", std::string("Alice"));
21720 base.setFieldValue({ 0 }, "score", static_cast<int32>(85));
21721 base.setFieldValue({ 1 }, "name", std::string("Bob"));
21722 base.setFieldValue({ 1 }, "score", static_cast<int32>(92));
21723
21724 // std::cout << "Base array:" << std::endl;
21725 //base.printArray();
21726
21727 std::vector<std::string> names = get_names(base);
21728 // std::cout << "Field names: ";
21729 for (const auto& name : names) {
21730 // std::cout << name << " ";
21731 }
21732 // std::cout << std::endl;
21733
21734 // std::cout << "Field structure: " << get_fieldstructure(base) << std::endl;
21735
21736 auto dropped = drop_fields(base, { "score" });
21737 // std::cout << "After dropping 'score' field:";
item (np_test_4_all.cpp:20048)
20038/**
20039 * @file np_test_phase6.cpp
20040 * @brief Test suite for Phase 6A - HIGH PRIORITY NDArray methods and masked array utilities
20041 *
20042 * Tests:
20043 * - ndarray.nonzero() - Return indices of non-zero elements
20044 * - ndarray.tobytes() - Convert to bytes representation
20045 * - ndarray.tolist() - Convert to nested list string
20046 * - ndarray.fill() - Fill with scalar value (in-place)
20047 * - ndarray.item() - Get single element as scalar
20048 * - ndarray.itemset() - Set single element value
20049 * - ma.masked_all_like() - Create masked array with all elements masked
20050 *
20051 * Created: 2025-10-28
20052 * Status: Phase 6A Implementation - HIGH PRIORITY functions
20053 */
20054
20055#include "../numpy/np_ndarray.h"
20056#include "../numpy/np_masked_array.h"
20057#include <iostream>
putmask (np_test_5_all.cpp:4659)
4649 mask.setElementAt({ 1 }, false);
4650 mask.setElementAt({ 2 }, true);
4651 mask.setElementAt({ 3 }, false);
4652 mask.setElementAt({ 4 }, true);
4653
4654 // Create value array
4655 numpy::NDArray<int32_t> values({ 1 });
4656 values.setElementAt({ 0 }, 99);
4657
4658 // Apply putmask
4659 numpy::putmask(arr, mask, values);
4660
4661 // Expected: [99, 2, 99, 4, 99]
4662 if (arr.getElementAt({ 0 }) != 99 || arr.getElementAt({ 1 }) != 2 ||
4663 arr.getElementAt({ 2 }) != 99 || arr.getElementAt({ 3 }) != 4 ||
4664 arr.getElementAt({ 4 }) != 99) {
4665 std::cout << " [FAIL] : in np_test_putmask() : Incorrect result";
4666 throw std::runtime_error("Test failed");
4667 }
4668
4669 // Test with multiple values
searchsorted (np_test_2_all.cpp:8204)
8194 // Test missing NumPy functions
8195 void test_numpy_functions() {
8196 std::cout << "========= NumPy Functions Test ==========================";
8197
8198 // Test searchsorted
8199 {
8200 std::vector<int> sorted_arr = { 1, 3, 5, 7, 9 };
8201 std::vector<int> values = { 2, 6, 8 };
8202
8203 auto result = numpy::searchsorted(sorted_arr, values, "left");
8204 std::vector<size_t> expected = { 1, 3, 4 };
8205
8206 if (result != expected) {
8207 std::cout << " searchsorted (left): -> [FAIL]";
8208 throw std::runtime_error("searchsorted (left): FAILED - incorrect result indices");
8209 }
8210 // std::cout << "[OK] searchsorted (left): PASSED" << std::endl;
8211
8212 auto result_right = numpy::searchsorted(sorted_arr, values, "right");
8213 std::vector<size_t> expected_right = { 1, 3, 4 };
take (np_test_5_all.cpp:4313)
4303 for (size_t i = 0; i < 6; ++i) {
4304 arr.setElementAt({ i }, static_cast<int32_t>(i * 10)); // [0, 10, 20, 30, 40, 50]
4305 }
4306
4307 // Take specific indices
4308 numpy::NDArray<size_t> indices({ 3 });
4309 indices.setElementAt({ 0 }, 5); // 50
4310 indices.setElementAt({ 1 }, 2); // 20
4311 indices.setElementAt({ 2 }, 0); // 0
4312
4313 auto result = numpy::take(arr, indices);
4314
4315 if (result.getSize() != 3) {
4316 std::cout << " [FAIL] : in np_test_take_basic() : Wrong result size";
4317 throw std::runtime_error("Test failed");
4318 }
4319
4320 if (result.getElementAt({ 0 }) != 50 || result.getElementAt({ 1 }) != 20 || result.getElementAt({ 2 }) != 0) {
4321 std::cout << " [FAIL] : in np_test_take_basic() : Wrong values extracted";
4322 throw std::runtime_error("Test failed");
4323 }
where (np_test_3_all.cpp:15253)
15243 auto y_data = createInt32Array({ 4 }, 0);
15244 y_data.setElementAt({ 0 }, 100);
15245 y_data.setElementAt({ 1 }, 200);
15246 y_data.setElementAt({ 2 }, 300);
15247 y_data.setElementAt({ 3 }, 400);
15248
15249 auto y_mask = createBoolArray({ 4 }, false);
15250 MaskedArray<int32> y(y_data, y_mask, -999);
15251
15252 // Test where() selection
15253 auto result = where(condition, x, y);
15254
15255 if (!(result.getElementAt({ 0 }) == 10)) {
15256 std::string description = std::string("test_where_selection():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({ 0 }) == 10)";
15257 std::cout << std::string("[FAIL] ") + description << std::endl;
15258 throw std::runtime_error(description);
15259 }
15260 if (!(result.getElementAt({ 1 }) == 200)) {
15261 std::string description = std::string("test_where_selection():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({ 1 }) == 200)";
15262 std::cout << std::string("[FAIL] ") + description << std::endl;
ravel (np_test_1_all.cpp:4082)
4072 std::cout << "Testing ravel function...\n";
4073
4074 // Test with 2-D array
4075 auto arr_2d = createFloat64Array({ 2, 3 });
4076 for (size_t i = 0; i < 2; ++i) {
4077 for (size_t j = 0; j < 3; ++j) {
4078 arr_2d.setElementAt({ i, j }, static_cast<double>(i * 3 + j));
4079 }
4080 }
4081
4082 auto raveled = ravel(arr_2d);
4083 if (!(raveled.getShape() == std::vector<size_t>({ 6 }))) {
4084 std::string description = std::string("testRavelFunction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(raveled.getShape() == std::vector<size_t>({ 6 }))";
4085 std::cout << std::string("[FAIL] ") + description << std::endl;
4086 throw std::runtime_error(description);
4087 }
4088
4089 for (size_t i = 0; i < 6; ++i) {
4090 if (!(isApproxEqualExt(raveled.getElementAt({ i }), static_cast<double>(i)))) {
4091 std::string description = std::string("testRavelFunction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isApproxEqualExt(raveled.getElementAt({ i }), static_cast<double>(i)))";
4092 std::cout << std::string("[FAIL] ") + description << std::endl;
transpose (np_test_2_all.cpp:4973)
4963 }
4964
4965 /**
4966 * Test matrix properties and methods
4967 */
4968 void testMatrixProperties() {
4969 std::cout << "========= testMatrixProperties =======================";
4970
4971 // Test transpose
4972 numpy::Matrix<double> m("1 2 3; 4 5 6");
4973 auto mt = m.transpose();
4974 assert_test(mt.rows() == 3, "Transpose rows");
4975 assert_test(mt.cols() == 2, "Transpose cols");
4976 assert_test(std::abs(mt(0, 1) - 4.0) < 1e-10, "Transpose element");
4977 assert_test(std::abs(mt(2, 0) - 3.0) < 1e-10, "Transpose element");
4978
4979 // Test trace for square matrix
4980 numpy::Matrix<double> square("1 2; 3 4");
4981 double tr = square.trace();
4982 assert_test(std::abs(tr - 5.0) < 1e-10, "Matrix trace");
max (np_test_1_all.cpp:7274)
7264 if (sizeof(uintp) == sizeof(void*)) {
7265 // std::cout << " -> uintp size matches pointer size";
7266 } else {
7267 // std::cout << " ✗ uintp size doesn't match pointer size" << std::endl;
7268 }
7269
7270 // Test range limits
7271 // std::cout << "Range Information:" << std::endl;
7272 // std::cout << " intp min: " << std::numeric_limits<intp>::min() << std::endl;
7273 // std::cout << " intp max: " << std::numeric_limits<intp>::max() << std::endl;
7274 // std::cout << " uintp max: " << std::numeric_limits<uintp>::max() << std::endl;
7275 // std::cout << " longdouble digits: " << std::numeric_limits<longdouble>::digits << std::endl;
7276
7277 std::cout << " -> tests passed" << std::endl;
7278}
7279
7280void testComplexArithmeticExtendedTypes() {
7281 std::cout << "========= testComplexArithmeticExtendedTypes =======================";
7282
7283 clongdouble c1(3.0L, 4.0L); // 3 + 4i
min (np_test_1_all.cpp:2350)
2340 if (i % 3 == 0) {
2341 large_array.setElementAt({i}, object_(static_cast<int>(i)));
2342 } else if (i % 3 == 1) {
2343 large_array.setElementAt({i}, object_(static_cast<double>(i) * 0.5));
2344 } else {
2345 large_array.setElementAt({i}, object_(std::string("str") + std::to_string(i)));
2346 }
2347 }
2348
2349 // Verify pattern
2350 for (size_t i = 0; i < std::min(large_size, size_t(100)); ++i) { // Check first 100
2351 object_ obj = large_array.getElementAt({i});
2352 if (i % 3 == 0) {
2353 if (!(obj.is_type<int>())) {
2354 std::string description = std::string("testArrayEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<int>())";
2355 std::cout << std::string("[FAIL] ") + description << std::endl;
2356 throw std::runtime_error(description);
2357 }
2358 } else if (i % 3 == 1) {
2359 if (!(obj.is_type<double>())) {
2360 std::string description = std::string("unknown_function():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(obj.is_type<double>())";
std (np_test_1_all.cpp:11836)
11826 auto var_sample = var(array, std::nullopt, 1); // ddof=1 for sample variance
11827 double expected_sample_var = 1.25 * 4.0 / 3.0; // Bessel's correction
11828 if (!(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))) {
11829 std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))";
11830 std::cout << std::string("[FAIL] ") + description << std::endl;
11831 throw std::runtime_error(description);
11832 }
11833 // std::cout << "[OK] Sample variance works correctly\n";
11834
11835 // Test standard deviation
11836 auto std_result = numpy::std(array, std::nullopt, 0);
11837 if (!(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))) {
11838 std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))";
11839 std::cout << std::string("[FAIL] ") + description << std::endl;
11840 throw std::runtime_error(description);
11841 }
11842 // std::cout << "[OK] Standard deviation works correctly\n";
11843
11844 // Test along axis
11845 auto array2d = createFloat64Array({ 2, 2 }, 0);
11846 array2d.setElementAt({ 0, 0 }, 1.0);
argsort (np_test_1_all.cpp:16841)
16831 std::cout << "========= test_argsort =======================";
16832
16833 // Test 1D array argsort
16834 NDArray<int> arr1d({ 5 });
16835 arr1d.setElementAt({ 0 }, 30); // index 0
16836 arr1d.setElementAt({ 1 }, 10); // index 1
16837 arr1d.setElementAt({ 2 }, 40); // index 2
16838 arr1d.setElementAt({ 3 }, 20); // index 3
16839 arr1d.setElementAt({ 4 }, 50); // index 4
16840
16841 auto indices = argsort(arr1d);
16842
16843 // Expected order: 10(idx1), 20(idx3), 30(idx0), 40(idx2), 50(idx4)
16844 if (!(indices.getElementAt({ 0 }) == 1)) {
16845 std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 0 }) == 1)";
16846 std::cout << std::string("[FAIL] ") + description << std::endl;
16847 throw std::runtime_error(description);
16848 }
16849 if (!(indices.getElementAt({ 1 }) == 3)) {
16850 std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 1 }) == 3)";
16851 std::cout << std::string("[FAIL] ") + description << std::endl;
sort (np_test_1_all.cpp:6258)
6248 std::vector<int> data = gen.generate(100, DataPattern::FEW_UNIQUE);
6249
6250 if (!(data.size() == 100)) {
6251 std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.size() == 100)";
6252 std::cout << std::string("[FAIL] ") + description << std::endl;
6253 throw std::runtime_error(description);
6254 }
6255
6256 // Count unique values
6257 std::vector<int> sorted_copy = data;
6258 std::sort(sorted_copy.begin(), sorted_copy.end());
6259 auto unique_end = std::unique(sorted_copy.begin(), sorted_copy.end());
6260 size_t unique_count = std::distance(sorted_copy.begin(), unique_end);
6261
6262 // Should have significantly fewer unique values than total elements
6263 if (!(unique_count < data.size() / 2)) {
6264 std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unique_count < data.size() / 2)";
6265 std::cout << std::string("[FAIL] ") + description << std::endl;
6266 throw std::runtime_error(description);
6267 }
sorted_arr (np_test_2_all.cpp:8750)
8740 if (!indices.empty()) {
8741 std::cout << " IPP empty values searchsorted: -> [FAIL]";
8742 throw std::runtime_error("IPP empty values searchsorted: FAILED - should return empty result");
8743 }
8744 // std::cout << "[OK] IPP empty values searchsorted: PASSED" << std::endl;
8745 }
8746
8747 // Test 6: Large array performance
8748 {
8749 const size_t n = 10000;
8750 std::vector<int> sorted_arr(n);
8751 std::iota(sorted_arr.begin(), sorted_arr.end(), 1); // [1, 2, 3, ..., n]
8752
8753 std::vector<int> values = { 100, 5000, 9999 };
8754
8755 auto start = std::chrono::high_resolution_clock::now();
8756 auto indices = numpy::searchsorted(sorted_arr, values, "left");
8757 auto end = std::chrono::high_resolution_clock::now();
8758
8759 std::vector<size_t> expected = { 99, 4999, 9998 }; // 0-indexed positions
ceil (np_test_2_all.cpp:5735)
5725 throw std::runtime_error(description);
5726 }
5727 if (!(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))) {
5728 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))";
5729 std::cout << std::string("[FAIL] ") + description << std::endl;
5730 throw std::runtime_error(description);
5731 }
5732 // std::cout << "[OK] floor function works correctly\n";
5733
5734 // Test ceil
5735 auto ceil_result = ceil(values);
5736 if (!(approx_equal(ceil_result.getElementAt({ 0 }), std::ceil(-2.7)))) {
5737 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(ceil_result.getElementAt({ 0 }), std::ceil(-2.7)))";
5738 std::cout << std::string("[FAIL] ") + description << std::endl;
5739 throw std::runtime_error(description);
5740 }
5741 if (!(approx_equal(ceil_result.getElementAt({ 5 }), std::ceil(2.7)))) {
5742 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(ceil_result.getElementAt({ 5 }), std::ceil(2.7)))";
5743 std::cout << std::string("[FAIL] ") + description << std::endl;
5744 throw std::runtime_error(description);
5745 }
floor (np_test_2_all.cpp:5721)
5711 throw std::runtime_error(description);
5712 }
5713 if (!(approx_equal(round_result.getElementAt({ 5 }), std::round(2.7)))) {
5714 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(round_result.getElementAt({ 5 }), std::round(2.7)))";
5715 std::cout << std::string("[FAIL] ") + description << std::endl;
5716 throw std::runtime_error(description);
5717 }
5718 // std::cout << "[OK] round function works correctly\n";
5719
5720 // Test floor
5721 auto floor_result = floor(values);
5722 if (!(approx_equal(floor_result.getElementAt({ 0 }), std::floor(-2.7)))) {
5723 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 0 }), std::floor(-2.7)))";
5724 std::cout << std::string("[FAIL] ") + description << std::endl;
5725 throw std::runtime_error(description);
5726 }
5727 if (!(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))) {
5728 std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))";
5729 std::cout << std::string("[FAIL] ") + description << std::endl;
5730 throw std::runtime_error(description);
5731 }
round (np_test_1_all.cpp:23769)
23759 throw std::runtime_error(description);
23760 }
23761 if (!(power_scalar_result.getShape() == array.getShape())) {
23762 std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(power_scalar_result.getShape() == array.getShape())";
23763 std::cout << std::string("[FAIL] ") + description << std::endl;
23764 throw std::runtime_error(description);
23765 }
23766 // std::cout << "[OK] Power functions have correct signatures\n";
23767
23768 // Test rounding functions with new decimals parameter
23769 auto round_result = round(array); // Default decimals=0
23770 auto round_decimals_result = round(array, 2); // With decimals
23771 if (!(round_result.getShape() == array.getShape())) {
23772 std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_result.getShape() == array.getShape())";
23773 std::cout << std::string("[FAIL] ") + description << std::endl;
23774 throw std::runtime_error(description);
23775 }
23776 if (!(round_decimals_result.getShape() == array.getShape())) {
23777 std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_decimals_result.getShape() == array.getShape())";
23778 std::cout << std::string("[FAIL] ") + description << std::endl;
23779 throw std::runtime_error(description);
normalize (np_test_5_all.cpp:22817)
22807 if (str.find("2024") == std::string::npos) { pass = false; fail_msg = "toString should contain year"; }
22808
22809 // isoformat
22810 std::string iso = ts.isoformat();
22811 if (iso.find("2024-06-15") == std::string::npos) { pass = false; fail_msg = "isoformat should contain date"; }
22812
22813 // isoformat with space separator
22814 std::string iso_space = ts.isoformat(' ');
22815 if (iso_space.find(" ") == std::string::npos) { pass = false; fail_msg = "isoformat with space separator"; }
22816
22817 // strftime
22818 std::string fmt = ts.strftime("%Y/%m/%d");
22819 if (fmt != "2024/06/15") { pass = false; fail_msg = "strftime format"; }
22820
22821 // ctime
22822 std::string ct = ts.ctime();
22823 if (ct.find("2024") == std::string::npos) { pass = false; fail_msg = "ctime should contain year"; }
22824
22825 // day_name
22826 std::string dayname = ts.day_name();
22827 if (dayname != "Saturday") { pass = false; fail_msg = "2024-06-15 is Saturday"; }
all (np_test_4_all.cpp:23928)
23918 }
23919 }
23920 }
23921
23922 auto result = numpy::einsum<numpy::float64>("ijk->ik", {A});
23923
23924 if (result.getShape()[0] != 2 || result.getShape()[1] != 2) {
23925 throw std::runtime_error("einsum partial sum shape wrong");
23926 }
23927
23928 // Sum over j: 1+2+3 = 6 for all (i,k) positions
23929 if (std::abs(result.getElementAt({0, 0}) - 6.0) > 1e-10 ||
23930 std::abs(result.getElementAt({1, 1}) - 6.0) > 1e-10) {
23931 throw std::runtime_error("einsum partial sum values wrong");
23932 }
23933
23934 // std::cout << " OK: Partial sum: 'ijk->ik'\n";
23935 }
23936
23937 // Test 5: Size-1 dimension handling
23938 {
any (np_test_2_all.cpp:16758)
16748 // ANY() TESTS - SCALAR RESULT
16749 // ============================================================================
16750
16751 void np_test_logic_any_scalar_all_false() {
16752 std::cout << "========= any: all false elements =======================";
16753
16754 // Create array with all false/zero elements
16755 std::vector<double> data = { 0.0, 0.0, 0.0 };
16756 numpy::NDArray<double> arr = numpy::createArrayFromVector<double>({ 3 }, data);
16757
16758 bool result = numpy::any(arr);
16759
16760 if (result != false) {
16761 std::cout << " [FAIL] : in np_test_logic_any_scalar_all_false() : expected false for all-zero array";
16762 throw std::runtime_error("np_test_logic_any_scalar_all_false failed: expected false");
16763 }
16764
16765 std::cout << " -> tests passed" << std::endl;
16766 }
16767
16768 void np_test_logic_any_scalar_all_true() {
isin (np_test_1_all.cpp:19434)
19424 std::cout << std::string("[FAIL] ") + description << std::endl;
19425 throw std::runtime_error(description);
19426 }
19427 if (!(membership.getElementAt({ 5 }) == false)) {
19428 std::string description = std::string("testMembershipOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(membership.getElementAt({ 5 }) == false)";
19429 std::cout << std::string("[FAIL] ") + description << std::endl;
19430 throw std::runtime_error(description);
19431 }
19432 // std::cout << "[OK] Membership testing (in1d) works correctly\n";
19433
19434 // Test isin (alias for in1d)
19435 auto isin_result = isin(test_array, test_values);
19436
19437 // Should be identical to in1d result
19438 for (size_t i = 0; i < membership.getSize(); ++i) {
19439 if (!(isin_result.getElementAt({ i }) == membership.getElementAt({ i }))) {
19440 std::string description = std::string("testMembershipOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(isin_result.getElementAt({ i }) == membership.getElementAt({ i }))";
19441 std::cout << std::string("[FAIL] ") + description << std::endl;
19442 throw std::runtime_error(description);
19443 }
19444 }
unique (np_test_1_all.cpp:6259)
6249 if (!(data.size() == 100)) {
6250 std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.size() == 100)";
6251 std::cout << std::string("[FAIL] ") + description << std::endl;
6252 throw std::runtime_error(description);
6253 }
6254
6255 // Count unique values
6256 std::vector<int> sorted_copy = data;
6257 std::sort(sorted_copy.begin(), sorted_copy.end());
6258 auto unique_end = std::unique(sorted_copy.begin(), sorted_copy.end());
6259 size_t unique_count = std::distance(sorted_copy.begin(), unique_end);
6260
6261 // Should have significantly fewer unique values than total elements
6262 if (!(unique_count < data.size() / 2)) {
6263 std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unique_count < data.size() / 2)";
6264 std::cout << std::string("[FAIL] ") + description << std::endl;
6265 throw std::runtime_error(description);
6266 }
6267
6268 // std::cout << "Few unique data generation test passed. Unique values: " << unique_count << std::endl;
to_numpy (np_test_5_all.cpp:21373)
21363 if (errors == 0) {
21364 std::cout << "np_test_timedelta_components -> tests passed" << std::endl;
21365 }
21366 return errors;
21367}
21368
21369// =============================================================================
21370// Test 4: Total Conversion Properties
21371// =============================================================================
21372int np_test_timedelta_total_conversions() {
21373 int errors = 0;
21374
21375 numpy::Timedelta td(1, 12, 0); // 1 day 12 hours = 1.5 days = 36 hours
21376
21377 // total_seconds
21378 {
21379 double secs = td.total_seconds();
21380 double expected = (24 + 12) * 3600.0;
21381 if (std::abs(secs - expected) > 0.0001) {
21382 std::cout << "[FAIL] np_test_timedelta_total_conversions: total_seconds expected "
21383 << expected << ", got " << secs << std::endl;
to_string (np_test_1_all.cpp:454)
444 // Modify through different views
445 view1.setElementAt({0, 0}, 100);
446 view2.setElementAt({2, 1}, 200); // This is (1, 2) in original
447 view3.setElementAt({0, 0}, 300); // This is (1, 1) in original
448
449 // std::cout << "After modifications through multiple views:" << std::endl;
450 //original.printArray();
451
452 // Verify all changes are reflected
453 if (!(original.getElementAt({0, 0}) == 100)) {
454 std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({0, 0}) == 100)";
455 std::cout << std::string("[FAIL] ") + description << std::endl;
456 throw std::runtime_error(description);
457 }
458 if (!(original.getElementAt({1, 2}) == 200)) {
459 std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 2}) == 200)";
460 std::cout << std::string("[FAIL] ") + description << std::endl;
461 throw std::runtime_error(description);
462 }
463 if (!(original.getElementAt({1, 1}) == 300)) {
464 std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 300)";
tolist (np_test_4_all.cpp:20046)
20036} // namespace numpy_tests
20037
20038/**
20039 * @file np_test_phase6.cpp
20040 * @brief Test suite for Phase 6A - HIGH PRIORITY NDArray methods and masked array utilities
20041 *
20042 * Tests:
20043 * - ndarray.nonzero() - Return indices of non-zero elements
20044 * - ndarray.tobytes() - Convert to bytes representation
20045 * - ndarray.tolist() - Convert to nested list string
20046 * - ndarray.fill() - Fill with scalar value (in-place)
20047 * - ndarray.item() - Get single element as scalar
20048 * - ndarray.itemset() - Set single element value
20049 * - ma.masked_all_like() - Create masked array with all elements masked
20050 *
20051 * Created: 2025-10-28
20052 * Status: Phase 6A Implementation - HIGH PRIORITY functions
20053 */
20054
20055#include "../numpy/np_ndarray.h"
append (np_test_2_all.cpp:7028)
7018 throw std::runtime_error(description);
7019 }
7020 if (!(deleted_dups.getElementAt({ 2 }) == 3)) {
7021 std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(deleted_dups.getElementAt({ 2 }) == 3)";
7022 std::cout << std::string("[FAIL] ") + description << std::endl;
7023 throw std::runtime_error(description);
7024 }
7025 // std::cout << "[OK] Delete with duplicate indices works correctly\n";
7026
7027 // Test append
7028 auto appended = append(array, 100);
7029 if (!(appended.getSize() == array.getSize() + 1)) {
7030 std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(appended.getSize() == array.getSize() + 1)";
7031 std::cout << std::string("[FAIL] ") + description << std::endl;
7032 throw std::runtime_error(description);
7033 }
7034 if (!(appended.getElementAt({ appended.getSize() - 1 }) == 100)) {
7035 std::string description = std::string("testModificationOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(appended.getElementAt({ appended.getSize() - 1 }) == 100)";
7036 std::cout << std::string("[FAIL] ") + description << std::endl;
7037 throw std::runtime_error(description);
7038 }
delete_ (np_test_4_all.cpp:18411)
18401 }
18402
18403 // ============================================================================
18404 // SPRINT 1.2: ESSENTIAL OPERATIONS TESTS
18405 // ============================================================================
18406
18407 void np_test_phase1_delete() {
18408 std::cout << "========= delete_: element deletion ====";
18409
18410 auto arr = numpy::array({10, 20, 30, 40, 50});
18411 auto result = numpy::delete_(arr, 2); // Delete index 2 (value 30)
18412
18413 // Verify size reduced
18414 if (result.getSize() != 4) {
18415 std::cout << " [FAIL] : delete_ result size is " << result.getSize() << ", expected 4\n";
18416 throw std::runtime_error("delete_ failed: wrong size");
18417 }
18418
18419 // Verify correct element was removed
18420 if (result.getElementAt({0}) != 10 || result.getElementAt({1}) != 20 ||
18421 result.getElementAt({2}) != 40 || result.getElementAt({3}) != 50) {
delete_ (np_test_4_all.cpp:18411)
18401 }
18402
18403 // ============================================================================
18404 // SPRINT 1.2: ESSENTIAL OPERATIONS TESTS
18405 // ============================================================================
18406
18407 void np_test_phase1_delete() {
18408 std::cout << "========= delete_: element deletion ====";
18409
18410 auto arr = numpy::array({10, 20, 30, 40, 50});
18411 auto result = numpy::delete_(arr, 2); // Delete index 2 (value 30)
18412
18413 // Verify size reduced
18414 if (result.getSize() != 4) {
18415 std::cout << " [FAIL] : delete_ result size is " << result.getSize() << ", expected 4\n";
18416 throw std::runtime_error("delete_ failed: wrong size");
18417 }
18418
18419 // Verify correct element was removed
18420 if (result.getElementAt({0}) != 10 || result.getElementAt({1}) != 20 ||
18421 result.getElementAt({2}) != 40 || result.getElementAt({3}) != 50) {
insert (np_test_1_all.cpp:6990)
6980}
6981
6982void testBusinessDateRangeDateTime() {
6983 std::cout << "========= testBusinessDateRangeDateTime =======================";
6984
6985 datetime64 start("2024-03-11"); // Monday
6986 datetime64 end("2024-03-22"); // Friday (2 weeks later)
6987
6988 // Create holidays set
6989 std::set<datetime64> holidays;
6990 holidays.insert(datetime64("2024-03-15")); // Friday holiday
6991
6992 auto business_dates = createBusinessDateRange(start, end, holidays);
6993 // std::cout << "Business dates from " << start.toString()
6994 // << " to " << end.toString() << " (excluding 2024-03-15):" << std::endl;
6995 //business_dates.printArray();
6996
6997 std::cout << " -> tests passed" << std::endl;
6998}
6999
7000void testMonthRangeDateTime() {
repeat (np_test_1_all.cpp:18268)
18258 // Create test array
18259 auto array = createInt32Array({ 2, 3 }, 0);
18260 for (size_t i = 0; i < 2; ++i) {
18261 for (size_t j = 0; j < 3; ++j) {
18262 array.setElementAt({ i, j }, static_cast<int32_t>(i * 3 + j + 1));
18263 }
18264 }
18265
18266 // Test repeat without axis (flattened)
18267 auto repeated_flat = repeat(array, 2);
18268 if (!(repeated_flat.getShape()[0] == 12)) {
18269 std::string description = std::string("testRepeat():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(repeated_flat.getShape()[0] == 12)";
18270 std::cout << std::string("[FAIL] ") + description << std::endl;
18271 throw std::runtime_error(description);
18272 }
18273 if (!(repeated_flat.getElementAt({ 0 }) == 1)) {
18274 std::string description = std::string("testRepeat():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(repeated_flat.getElementAt({ 0 }) == 1)";
18275 std::cout << std::string("[FAIL] ") + description << std::endl;
18276 throw std::runtime_error(description);
18277 }
astype (np_test_3_all.cpp:796)
786 auto ufunc_square = numpy::frompyfunc(square, 1, 1);
787
788 numpy::NDArray<double> arr({ 3 });
789 arr.setElementAt({ 0 }, 2.0);
790 arr.setElementAt({ 1 }, 3.0);
791 arr.setElementAt({ 2 }, 4.0);
792
793 auto result = ufunc_square(arr);
794
795 // Convert back to double to check values
796 auto typed_result = numpy::astype<double>(result);
797 if (std::abs(typed_result.getElementAt({ 0 }) - 4.0) > 1e-10 ||
798 std::abs(typed_result.getElementAt({ 1 }) - 9.0) > 1e-10 ||
799 std::abs(typed_result.getElementAt({ 2 }) - 16.0) > 1e-10) {
800 std::cout << "[FAIL] Basic frompyfunc creation failed";
801 return 1;
802 }
803
804 // std::cout << "[OK] Basic frompyfunc creation works correctly" << std::endl;
805 std::cout << " -> tests passed" << std::endl;
806 return 0;
copy (np_test_1_all.cpp:9812)
9802 //original.printArray();
9803
9804 // The modification should be at position (1,1) in original
9805 if (!(original.getElementAt({1, 1}) == 9999)) {
9806 std::string description = std::string("testSliceCopyVsViewMemoryOwnership():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 9999)";
9807 std::cout << std::string("[FAIL] ") + description << std::endl;
9808 throw std::runtime_error(description);
9809 }
9810 // std::cout << "[OK] Slice view shares memory with original";
9811
9812 // Test slice copy (should be independent)
9813 auto slice_copy = original.sliceArray({{2, 4}, {2, 4}});
9814 // std::cout << "Slice copy [2:4, 2:4]:";
9815 //slice_copy.printArray();
9816
9817 slice_copy.setElementAt({0, 0}, 7777);
9818
9819 // std::cout << "After modifying slice copy at (0,0):" << std::endl;
9820 // std::cout << "Original array:" << std::endl;
9821 //original.printArray();
9822 // std::cout << "Slice copy:" << std::endl;
view (np_test_1_all.cpp:440)
430 for (size_t i = 0; i < 3; ++i) {
431 for (size_t j = 0; j < 3; ++j) {
432 original.setElementAt({i, j}, static_cast<int32_t>(i * 3 + j));
433 }
434 }
435
436 // std::cout << "Original array:" << std::endl;
437 //original.printArray();
438
439 // Create multiple views
440 auto view1 = original.view();
441 auto view2 = original.transposeView();
442 auto view3 = original.sliceView({{1, 3}, {1, 3}});
443
444 // Modify through different views
445 view1.setElementAt({0, 0}, 100);
446 view2.setElementAt({2, 1}, 200); // This is (1, 2) in original
447 view3.setElementAt({0, 0}, 300); // This is (1, 1) in original
448
449 // std::cout << "After modifications through multiple views:" << std::endl;
450 //original.printArray();
is_numeric (np_test_1_all.cpp:7511)
7501 std::cout << " -> tests passed" << std::endl;
7502}
7503
7504void testNumericConversionStringTypes() {
7505 std::cout << "========= testNumericStringOperationsStringTypes =======================";
7506
7507 str32 num_str1("123.45");
7508 str32 num_str2("67.89");
7509 str32 not_num("hello");
7510
7511 // std::cout << "String '" << num_str1 << "' is numeric: " << is_numeric(num_str1) << std::endl;
7512 // std::cout << "String '" << not_num << "' is numeric: " << is_numeric(not_num) << std::endl;
7513
7514 if (is_numeric(num_str1)) {
7515 double val1 = to_numeric(num_str1);
7516 // std::cout << "Numeric value of '" << num_str1 << "': " << val1 << std::endl;
7517 }
7518
7519 if (is_numeric(num_str2)) {
7520 double val2 = to_numeric(num_str2);
7521 // std::cout << "Numeric value of '" << num_str2 << "': " << val2 << std::endl;
argmax (np_test_3_all.cpp:20521)
20511 auto result = numpy::argmin(arr);
20512 // Should return 1 (index of (1,5))
20513 if (result.getElementAt({0}) != 1) {
20514 throw std::runtime_error("argmin() failed: expected index 1");
20515 }
20516 std::cout << "PASSED\n";
20517}
20518
20519void test_argmax_complex128() {
20520 std::cout << " Testing argmax() with complex128... ";
20521 numpy::NDArray<complex128> arr({3});
20522 arr.setElementAt({0}, complex128(3.0, 1.0)); // index 0 - largest
20523 arr.setElementAt({1}, complex128(1.0, 5.0)); // index 1
20524 arr.setElementAt({2}, complex128(2.0, 2.0)); // index 2
20525
20526 auto result = numpy::argmax(arr);
20527 // Should return 0 (index of (3,1))
20528 if (result.getElementAt({0}) != 0) {
20529 throw std::runtime_error("argmax() failed: expected index 0");
20530 }
argmin (np_test_3_all.cpp:20506)
20496 if (min_result.getElementAt({0}).real() != 2.0 || min_result.getElementAt({0}).imag() != 1.0) {
20497 throw std::runtime_error("min() tie-breaking failed: expected (2,1)");
20498 }
20499 if (max_result.getElementAt({0}).real() != 2.0 || max_result.getElementAt({0}).imag() != 5.0) {
20500 throw std::runtime_error("max() tie-breaking failed: expected (2,5)");
20501 }
20502 std::cout << "PASSED\n";
20503}
20504
20505void test_argmin_complex128() {
20506 std::cout << " Testing argmin() with complex128... ";
20507 numpy::NDArray<complex128> arr({3});
20508 arr.setElementAt({0}, complex128(3.0, 1.0)); // index 0
20509 arr.setElementAt({1}, complex128(1.0, 5.0)); // index 1 - smallest
20510 arr.setElementAt({2}, complex128(2.0, 2.0)); // index 2
20511
20512 auto result = numpy::argmin(arr);
20513 // Should return 1 (index of (1,5))
20514 if (result.getElementAt({0}) != 1) {
20515 throw std::runtime_error("argmin() failed: expected index 1");
20516 }
arr (np_test_1_all.cpp:1388)
1378 std::cout << std::string("[FAIL] ") + description << std::endl;
1379 throw std::runtime_error(description);
1380 }
1381 if (!(*str_obj.get_as<std::string>() == "hello")) {
1382 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
1383 std::cout << std::string("[FAIL] ") + description << std::endl;
1384 throw std::runtime_error(description);
1385 }
1386
1387 // Test NDArray construction
1388 NDArray<double> arr({2, 2}, 3.14);
1389 object_ arr_obj(arr);
1390 if (!(!arr_obj.is_null())) {
1391 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
1392 std::cout << std::string("[FAIL] ") + description << std::endl;
1393 throw std::runtime_error(description);
1394 }
1395 if (!(arr_obj.is_array())) {
1396 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
1397 std::cout << std::string("[FAIL] ") + description << std::endl;
1398 throw std::runtime_error(description);
arr (np_test_1_all.cpp:1388)
1378 std::cout << std::string("[FAIL] ") + description << std::endl;
1379 throw std::runtime_error(description);
1380 }
1381 if (!(*str_obj.get_as<std::string>() == "hello")) {
1382 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(*str_obj.get_as<std::string>() == \"hello\")";
1383 std::cout << std::string("[FAIL] ") + description << std::endl;
1384 throw std::runtime_error(description);
1385 }
1386
1387 // Test NDArray construction
1388 NDArray<double> arr({2, 2}, 3.14);
1389 object_ arr_obj(arr);
1390 if (!(!arr_obj.is_null())) {
1391 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!arr_obj.is_null())";
1392 std::cout << std::string("[FAIL] ") + description << std::endl;
1393 throw std::runtime_error(description);
1394 }
1395 if (!(arr_obj.is_array())) {
1396 std::string description = std::string("testObjectConstruction():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(arr_obj.is_array())";
1397 std::cout << std::string("[FAIL] ") + description << std::endl;
1398 throw std::runtime_error(description);
as_unit (np_test_5_all.cpp:22866)
22856 if (iso_week < 1 || iso_week > 53) { pass = false; fail_msg = "ISO week range"; }
22857 if (iso_day < 1 || iso_day > 7) { pass = false; fail_msg = "ISO day range 1-7"; }
22858
22859 // isoweekday (1=Monday, 7=Sunday)
22860 int isowd = ts.isoweekday();
22861 if (isowd != 6) { pass = false; fail_msg = "2024-06-15 is Saturday = 6"; }
22862
22863 // weekday (0=Monday, 6=Sunday)
22864 int wd = ts.weekday();
22865 if (wd != 5) { pass = false; fail_msg = "2024-06-15 is Saturday = 5"; }
22866
22867 if (!pass) {
22868 std::cout << " [FAIL] : in np_test_timestamp_calendar() : " << fail_msg;
22869 throw std::runtime_error("np_test_timestamp_calendar failed: " + fail_msg);
22870 }
22871
22872 std::cout << " -> tests passed" << std::endl;
22873 }
22874
22875 // ============================================================================
22876 // ROUNDING TESTS
clone (np_test_1_all.cpp:24942)
24932 }
24933
24934 // Test reproducibility
24935 numpy::random::PCG64DXSM rng2(11111);
24936 if (rng2.next_uint64() != val) {
24937 std::cout << " [FAIL] : in np_test_bitgen_pcg64dxsm() : not reproducible";
24938 throw std::runtime_error("np_test_bitgen_pcg64dxsm failed");
24939 }
24940
24941 // Test clone
24942 auto cloned = rng.clone();
24943 if (cloned->name() != "PCG64DXSM") {
24944 std::cout << " [FAIL] : in np_test_bitgen_pcg64dxsm() : clone name incorrect";
24945 throw std::runtime_error("np_test_bitgen_pcg64dxsm failed");
24946 }
24947
24948 std::cout << " -> tests passed" << std::endl;
24949 }
24950
24951 // ============================================================================
24952 // PHILOX TESTS
diff (np_test_2_all.cpp:4947)
4937 // Test matrix addition and subtraction
4938 numpy::Matrix<double> a("1 2; 3 4");
4939 numpy::Matrix<double> b("5 6; 7 8");
4940
4941 auto sum = a + b;
4942 assert_test(std::abs(sum(0, 0) - 6.0) < 1e-10, "Matrix addition");
4943 assert_test(std::abs(sum(1, 1) - 12.0) < 1e-10, "Matrix addition");
4944
4945 auto diff = b - a;
4946 assert_test(std::abs(diff(0, 0) - 4.0) < 1e-10, "Matrix subtraction");
4947 assert_test(std::abs(diff(1, 1) - 4.0) < 1e-10, "Matrix subtraction");
4948
4949 // Test matrix multiplication (not element-wise!)
4950 auto product = a * b;
4951 assert_test(std::abs(product(0, 0) - 19.0) < 1e-10, "Matrix multiplication 0,0");
4952 assert_test(std::abs(product(0, 1) - 22.0) < 1e-10, "Matrix multiplication 0,1");
4953 assert_test(std::abs(product(1, 0) - 43.0) < 1e-10, "Matrix multiplication 1,0");
4954 assert_test(std::abs(product(1, 1) - 50.0) < 1e-10, "Matrix multiplication 1,1");
4955
4956 // Test scalar multiplication
difference (np_test_1_all.cpp:19333)
19323 std::cout << std::string("[FAIL] ") + description << std::endl;
19324 throw std::runtime_error(description);
19325 }
19326 if (!(difference.getElementAt({ 2 }) == 5)) {
19327 std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(difference.getElementAt({ 2 }) == 5)";
19328 std::cout << std::string("[FAIL] ") + description << std::endl;
19329 throw std::runtime_error(description);
19330 }
19331 // std::cout << "[OK] Set difference works correctly\n";
19332
19333 // Test symmetric difference (XOR)
19334 auto xor_result = setxor1d(arr1, arr2);
19335
19336 if (!(xor_result.getSize() == 4)) {
19337 std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(xor_result.getSize() == 4)";
19338 std::cout << std::string("[FAIL] ") + description << std::endl;
19339 throw std::runtime_error(description);
19340 }
19341 if (!(xor_result.getElementAt({ 0 }) == 1)) {
19342 std::string description = std::string("testSetDifferenceOperations():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(xor_result.getElementAt({ 0 }) == 1)";
19343 std::cout << std::string("[FAIL] ") + description << std::endl;
format (main.cpp:22)
12int main() {
13 // Automatically log all output to temp/test_output.log
14 numpy::TestLogger logger("temp/test_output.log");
15
16 int res = 0;
17 int res1 = 0;
18 std::string resS = "";
19
20 // call all the tests
21 res1 = numpy_tests::np_test_main();
22 resS += std::format(" np_test_main: {} errors\n", res1);
23 res += res1;
24
25 std::cout << "\n------------------------- main --------------------------------------------\n";
26 std::cout << std::endl << "All tests completed. Nb errors = " << res << std::endl;
27 std::cout << "Details: \n" << resS;
28 std::cout << "\n---------------------------------------------------------------------------\n";
29 return res;
30}
join (np_test_5_all.cpp:1341)
1331 // ============================================================================
1332
1333 void np_test_string_join() {
1334 std::cout << "========= join operation =======================";
1335
1336 // Join takes a separator string and vector of CharArrays
1337 std::vector<numpy::CharArray<32>> arrays;
1338 arrays.push_back(numpy::char_::array<32>({ "a", "b", "c" }));
1339 arrays.push_back(numpy::char_::array<32>({ "x", "y", "z" }));
1340
1341 auto result = numpy::char_::join("-", arrays);
1342
1343 bool passed = true;
1344
1345 if (!passed) {
1346 std::cout << " [FAIL] : in np_test_string_join() : join operation failed";
1347 throw std::runtime_error("np_test_string_join failed");
1348 }
1349
1350 std::cout << " -> tests passed" << std::endl;
1351 }
shift (np_test_1_all.cpp:2761)
2751 throw std::runtime_error(description);
2752 }
2753 if (!(left_array.getElementAt({3}) == 16384)) {
2754 std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(left_array.getElementAt({3}) == 16384)";
2755 std::cout << std::string("[FAIL] ") + description << std::endl;
2756 throw std::runtime_error(description);
2757 }
2758
2759 // std::cout << "[OK] Left shift by array\n";
2760
2761 // Test excessive shift (should result in 0)
2762 auto excessive_left = left_shift(arr, 20); // More than 16 bits
2763 if (!(excessive_left.getElementAt({0}) == 0)) {
2764 std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(excessive_left.getElementAt({0}) == 0)";
2765 std::cout << std::string("[FAIL] ") + description << std::endl;
2766 throw std::runtime_error(description);
2767 }
2768 if (!(excessive_left.getElementAt({1}) == 0)) {
2769 std::string description = std::string("testBitShifts():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(excessive_left.getElementAt({1}) == 0)";
2770 std::cout << std::string("[FAIL] ") + description << std::endl;
2771 throw std::runtime_error(description);
tz_convert (np_test_5_all.cpp:22899)
22889 if (floored_h.hour() != 14 || floored_h.minute() != 0 || floored_h.second() != 0) {
22890 pass = false;
22891 fail_msg = "floor to hour failed";
22892 }
22893
22894 // ceil to hour
22895 numpy::Timestamp ceiled_h = ts.ceil("h");
22896 if (ceiled_h.hour() != 15 || ceiled_h.minute() != 0) {
22897 pass = false;
22898 fail_msg = "ceil to hour failed";
22899 }
22900
22901 // round to hour (37 minutes -> round up)
22902 numpy::Timestamp rounded_h = ts.round("h");
22903 if (rounded_h.hour() != 15) {
22904 pass = false;
22905 fail_msg = "round to hour should be 15 (37 > 30)";
22906 }
22907
22908 // normalize (floor to day)
22909 numpy::Timestamp normalized = ts.normalize();
tz_localize (np_test_5_all.cpp:22892)
22882 auto pass = true;
22883 std::string fail_msg;
22884
22885 numpy::Timestamp ts(2024, 6, 15, 14, 37, 45, 123456);
22886
22887 // floor to hour
22888 numpy::Timestamp floored_h = ts.floor("h");
22889 if (floored_h.hour() != 14 || floored_h.minute() != 0 || floored_h.second() != 0) {
22890 pass = false;
22891 fail_msg = "floor to hour failed";
22892 }
22893
22894 // ceil to hour
22895 numpy::Timestamp ceiled_h = ts.ceil("h");
22896 if (ceiled_h.hour() != 15 || ceiled_h.minute() != 0) {
22897 pass = false;
22898 fail_msg = "ceil to hour failed";
22899 }
22900
22901 // round to hour (37 minutes -> round up)
22902 numpy::Timestamp rounded_h = ts.round("h");