FloatingArray
=============

.. cpp:class:: numpy::FloatingArray

   numpy C++ class.

Example
-------

.. code-block:: cpp

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

   // Use FloatingArray
   FloatingArray obj;
   // ... operations ...

Constructors
------------

.. list-table::
   :widths: 55 25 20
   :header-rows: 1

   * - Signature
     - Location
     - Example
   * - ``FloatingArray(const numpy::NDArray<T>& data, const numpy::NDArray<numpy::bool\_>& mask, bool copy = false)``
     - df_floating_array.h:69
     - 
   * - ``explicit FloatingArray(const numpy::NDArray<T>& data)``
     - df_floating_array.h:83
     - 
   * - ``explicit FloatingArray(const std::vector<std::optional<T>>& values)``
     - df_floating_array.h:115
     - 

Construction
------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``static FloatingArray<T> from_sequence(const std::vector<std::optional<T>>& scalars)``
     - static FloatingArray<T>
     - df_floating_array.h:320
     - 

Array Creation
--------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool empty() const``
     - bool
     - df_floating_array.h:172
     - :ref:`View <example-floatingarray-empty-0>`

Indexing / Selection
--------------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``T at(size_t index) const``
     - T
     - df_floating_array.h:217
     - :ref:`View <example-floatingarray-at-1>`
   * - ``FloatingArray<T> take(const std::vector<size_t>& indices, bool allow_fill = false, std::optional<T> fill_value = std::nullopt) const``
     - FloatingArray<T>
     - df_floating_array.h:267
     - :ref:`View <example-floatingarray-take-2>`

Statistics
----------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::optional<T> max(bool skipna = true) const``
     - std::optional<T>
     - df_floating_array.h:783
     - :ref:`View <example-floatingarray-max-3>`
   * - ``std::optional<double> mean(bool skipna = true) const``
     - std::optional<double>
     - df_floating_array.h:742
     - :ref:`View <example-floatingarray-mean-4>`
   * - ``std::optional<T> min(bool skipna = true) const``
     - std::optional<T>
     - df_floating_array.h:763
     - :ref:`View <example-floatingarray-min-5>`
   * - ``std::optional<double> std(bool skipna = true, int ddof = 1) const``
     - std::optional<double>
     - df_floating_array.h:803
     - :ref:`View <example-floatingarray-std-6>`
   * - ``std::optional<T> sum(bool skipna = true) const``
     - std::optional<T>
     - df_floating_array.h:721
     - :ref:`View <example-floatingarray-sum-7>`
   * - ``std::optional<double> var(bool skipna = true, int ddof = 1) const``
     - std::optional<double>
     - df_floating_array.h:812
     - :ref:`View <example-floatingarray-var-8>`

Sorting
-------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<size_t> argsort(bool ascending = true, const std::string& na_position = "last") const``
     - numpy::NDArray<size_t>
     - df_floating_array.h:544
     - :ref:`View <example-floatingarray-argsort-9>`

Math Operations
---------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``FloatingArray<T> ceil() const``
     - FloatingArray<T>
     - df_floating_array.h:920
     - :ref:`View <example-floatingarray-ceil-10>`
   * - ``FloatingArray<T> floor() const``
     - FloatingArray<T>
     - df_floating_array.h:903
     - :ref:`View <example-floatingarray-floor-11>`
   * - ``FloatingArray<T> round(int decimals = 0) const``
     - FloatingArray<T>
     - df_floating_array.h:884
     - :ref:`View <example-floatingarray-round-12>`

Logical
-------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool all() const``
     - bool
     - df_floating_array.h:868
     - :ref:`View <example-floatingarray-all-13>`
   * - ``bool any() const``
     - bool
     - df_floating_array.h:856
     - :ref:`View <example-floatingarray-any-14>`
   * - ``numpy::NDArray<numpy::bool\_> isfinite() const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:462
     - :ref:`View <example-floatingarray-isfinite-15>`
   * - ``numpy::NDArray<numpy::bool\_> isinf() const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:447
     - :ref:`View <example-floatingarray-isinf-16>`
   * - ``numpy::NDArray<numpy::bool\_> isnan_data() const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:432
     - 

Set Operations
--------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``FloatingArray<T> unique() const``
     - FloatingArray<T>
     - df_floating_array.h:481
     - :ref:`View <example-floatingarray-unique-17>`

I/O
---

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``numpy::NDArray<T> to_numpy(T na_value = T``
     - numpy::NDArray<T>
     - df_floating_array.h:383
     - :ref:`View <example-floatingarray-to_numpy-18>`
   * - ``numpy::NDArray<T> to_numpy_nan() const``
     - numpy::NDArray<T>
     - df_floating_array.h:396
     - 
   * - ``std::string to_string() const``
     - std::string
     - df_floating_array.h:938
     - :ref:`View <example-floatingarray-to_string-19>`

Type Handling
-------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``FloatingArray<T> copy() const``
     - FloatingArray<T>
     - df_floating_array.h:257
     - :ref:`View <example-floatingarray-copy-20>`

Type Checking
-------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``bool is_na(size_t index) const``
     - bool
     - df_floating_array.h:228
     - 

Other Methods
-------------

.. list-table::
   :widths: 40 20 15 25
   :header-rows: 1

   * - Signature
     - Return Type
     - Location
     - Example
   * - ``std::optional<size_t> argmax() const``
     - std::optional<size_t>
     - df_floating_array.h:594
     - :ref:`View <example-floatingarray-argmax-21>`
   * - ``std::optional<size_t> argmin() const``
     - std::optional<size_t>
     - df_floating_array.h:575
     - :ref:`View <example-floatingarray-argmin-22>`
   * - ``FloatingArray<T> binary_op(const FloatingArray<T>& other, Op op) const``
     - FloatingArray<T>
     - df_floating_array.h:999
     - 
   * - ``numpy::NDArray<numpy::bool\_> compare_op(const FloatingArray<T>& other, Op op) const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:1036
     - 
   * - ``static FloatingArray<T> concat(const std::vector<FloatingArray<T>>& arrays)``
     - static FloatingArray<T>
     - df_floating_array.h:327
     - 
   * - ``void convert_nan_to_na()``
     - void
     - df_floating_array.h:989
     - 
   * - ``size_t count() const``
     - size_t
     - df_floating_array.h:403
     - :ref:`View <example-floatingarray-count-23>`
   * - ``const numpy::NDArray<T>& data() const``
     - const numpy::NDArray<T>&
     - df_floating_array.h:190
     - :ref:`View <example-floatingarray-data-24>`
   * - ``FloatingArray<T> dropna() const``
     - FloatingArray<T>
     - df_floating_array.h:370
     - 
   * - ``dtype_type dtype() const``
     - dtype_type
     - df_floating_array.h:137
     - :ref:`View <example-floatingarray-dtype-25>`
   * - ``std::pair<numpy::NDArray<numpy::int64>, FloatingArray<T>> factorize() const``
     - std::pair<numpy::NDArray<numpy::int64>, FloatingArray<T>>
     - df_floating_array.h:508
     - 
   * - ``FloatingArray<T> fillna(T value) const``
     - FloatingArray<T>
     - df_floating_array.h:356
     - 
   * - ``bool has_na() const``
     - bool
     - df_floating_array.h:416
     - 
   * - ``numpy::NDArray<numpy::bool\_> isna() const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:239
     - 
   * - ``size_t len() const``
     - size_t
     - df_floating_array.h:179
     - 
   * - ``const numpy::NDArray<numpy::bool\_>& mask() const``
     - const numpy::NDArray<numpy::bool\_>&
     - df_floating_array.h:197
     - :ref:`View <example-floatingarray-mask-26>`
   * - ``size_t nbytes() const``
     - size_t
     - df_floating_array.h:151
     - :ref:`View <example-floatingarray-nbytes-27>`
   * - ``constexpr int ndim() const``
     - constexpr int
     - df_floating_array.h:158
     - :ref:`View <example-floatingarray-ndim-28>`
   * - ``numpy::NDArray<numpy::bool\_> notna() const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:246
     - 
   * - ``op(data\_.getElementAt(``
     - 
     - df_floating_array.h:1049
     - 
   * - ``op(data\_.getElementAt(``
     - 
     - df_floating_array.h:1065
     - 
   * - ``std::optional<T> prod(bool skipna = true) const``
     - std::optional<T>
     - df_floating_array.h:835
     - :ref:`View <example-floatingarray-prod-29>`
   * - ``std::string repr() const``
     - std::string
     - df_floating_array.h:955
     - 
   * - ``numpy::NDArray<numpy::bool\_> scalar_compare(T scalar, Op op) const``
     - numpy::NDArray<numpy::bool\_>
     - df_floating_array.h:1057
     - 
   * - ``FloatingArray<T> scalar_op(T scalar, Op op) const``
     - FloatingArray<T>
     - df_floating_array.h:1020
     - 
   * - ``std::vector<size_t> shape() const``
     - std::vector<size_t>
     - df_floating_array.h:165
     - :ref:`View <example-floatingarray-shape-30>`
   * - ``size_t size() const``
     - size_t
     - df_floating_array.h:144
     - :ref:`View <example-floatingarray-size-31>`
   * - ``void validate_arrays()``
     - void
     - df_floating_array.h:968
     - 


Code Examples
-------------

The following examples are extracted from the test suite.

.. _example-floatingarray-empty-0:

.. dropdown:: empty (np_test_1_all.cpp:6316)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6306
      :emphasize-lines: 11

      }
      
      void test_data_generator_emptyBenchmarkSorting() {
          std::cout << "========= test_data_generator_empty =======================";
      
          DataGenerator<int> gen(42);
      
          // Test empty data generation
          std::vector<int> data = gen.generate(0, DataPattern::RANDOM);
      
          if (!(data.empty())) {
              std::string description = std::string("test_data_generator_emptyBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.empty())";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // std::cout << "Empty data generation test passed" << std::endl;
      
          std::cout << " -> tests passed" << std::endl;
      }
      

.. _example-floatingarray-at-1:

.. dropdown:: at (np_test_1_all.cpp:144)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 134
      :emphasize-lines: 11

      
          array.setElementAt({0, 0}, 1);
          array.setElementAt({0, 1}, 2);
          array.setElementAt({0, 2}, 3);
          array.setElementAt({1, 1}, 5);
          array.setElementAt({2, 2}, 9);
      
          // std::cout << "Array after setting elements:" << std::endl;
          //array.printArray();
      
          // std::cout << "Element at (1,1): " << array.getElementAt({1, 1}) << std::endl;
          // std::cout << "Element at (2,2): " << array.getElementAt({2, 2});
      
          std::cout << " -> tests passed" << std::endl;
      }
      
      void testArithmetic() {
          std::cout << "========= testArithmeticOperations =======================";
      
          auto array1 = createFloat32Array({2, 2}, 5.0f);
          auto array2 = createFloat32Array({2, 2}, 3.0f);

.. _example-floatingarray-take-2:

.. dropdown:: take (np_test_5_all.cpp:4313)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 4303
      :emphasize-lines: 11

            for (size_t i = 0; i < 6; ++i) {
              arr.setElementAt({ i }, static_cast<int32_t>(i * 10));  // [0, 10, 20, 30, 40, 50]
            }
      
            // Take specific indices
            numpy::NDArray<size_t> indices({ 3 });
            indices.setElementAt({ 0 }, 5);  // 50
            indices.setElementAt({ 1 }, 2);  // 20
            indices.setElementAt({ 2 }, 0);  // 0
      
            auto result = numpy::take(arr, indices);
      
            if (result.getSize() != 3) {
              std::cout << "  [FAIL] : in np_test_take_basic() : Wrong result size";
              throw std::runtime_error("Test failed");
            }
      
            if (result.getElementAt({ 0 }) != 50 || result.getElementAt({ 1 }) != 20 || result.getElementAt({ 2 }) != 0) {
              std::cout << "  [FAIL] : in np_test_take_basic() : Wrong values extracted";
              throw std::runtime_error("Test failed");
            }

.. _example-floatingarray-max-3:

.. dropdown:: max (np_test_1_all.cpp:7274)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 7264
      :emphasize-lines: 11

      
          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

.. _example-floatingarray-mean-4:

.. dropdown:: mean (np_test_1_all.cpp:11714)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11704
      :emphasize-lines: 11

          // Create test array
          auto array = createInt32Array({ 2, 3 }, 0);
          array.setElementAt({ 0, 0 }, 1);
          array.setElementAt({ 0, 1 }, 2);
          array.setElementAt({ 0, 2 }, 3);
          array.setElementAt({ 1, 0 }, 4);
          array.setElementAt({ 1, 1 }, 5);
          array.setElementAt({ 1, 2 }, 6);
      
          // Test mean without axis
          auto mean_all = mean(array);
          if (!(approx_equal(mean_all.getElementAt({ 0 }), 3.5, 1e-10))) {
              std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(mean_all.getElementAt({ 0 }), 3.5, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] mean (all elements) works correctly\n";
      
          // Test mean along axis 0
          auto mean_axis0 = mean(array, 0);
          if (!(mean_axis0.getShape()[0] == 3)) {

.. _example-floatingarray-min-5:

.. dropdown:: min (np_test_1_all.cpp:2350)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2340
      :emphasize-lines: 11

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

.. _example-floatingarray-std-6:

.. dropdown:: std (np_test_1_all.cpp:11836)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11826
      :emphasize-lines: 11

          auto var_sample = var(array, std::nullopt, 1);  // ddof=1 for sample variance
          double expected_sample_var = 1.25 * 4.0 / 3.0;  // Bessel's correction
          if (!(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))) {
              std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(var_sample.getElementAt({ 0 }), expected_sample_var, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Sample variance works correctly\n";
      
          // Test standard deviation
          auto std_result = numpy::std(array, std::nullopt, 0);
          if (!(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))) {
              std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(std_result.getElementAt({ 0 }), std::sqrt(expected_var), 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Standard deviation works correctly\n";
      
          // Test along axis
          auto array2d = createFloat64Array({ 2, 2 }, 0);
          array2d.setElementAt({ 0, 0 }, 1.0);

.. _example-floatingarray-sum-7:

.. dropdown:: sum (np_test_1_all.cpp:11766)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11756
      :emphasize-lines: 11

              throw std::runtime_error(description);
          }
          if (!(approx_equal(mean_axis1.getElementAt({ 1 }), 5.0, 1e-10))) {
              std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(mean_axis1.getElementAt({ 1 }), 5.0, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] mean along axis 1 works correctly\n";
      
          // Test sum
          auto sum_all = sum(array);
          if (!(sum_all.getElementAt({ 0 }) == 21)) {
              std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(sum_all.getElementAt({ 0 }) == 21)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] sum works correctly\n";
      
          // Test min and max
          auto min_all = min(array);
          auto max_all = max(array);

.. _example-floatingarray-var-8:

.. dropdown:: var (np_test_1_all.cpp:11816)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11806
      :emphasize-lines: 11

          std::cout << "========= testVarianceAndStandardDeviation =======================";
      
          // Create test array with known variance
          auto array = createFloat64Array({ 4 }, 0);
          array.setElementAt({ 0 }, 1.0);
          array.setElementAt({ 1 }, 2.0);
          array.setElementAt({ 2 }, 3.0);
          array.setElementAt({ 3 }, 4.0);
      
          // Test variance (population)
          auto var_result = var(array, std::nullopt, 0);  // ddof=0 for population variance
          double expected_var = 1.25;  // Known variance for [1,2,3,4]
          if (!(approx_equal(var_result.getElementAt({ 0 }), expected_var, 1e-10))) {
              std::string description = std::string("testVarianceAndStandardDeviation():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(var_result.getElementAt({ 0 }), expected_var, 1e-10))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Population variance works correctly\n";
      
          // Test variance (sample)
          auto var_sample = var(array, std::nullopt, 1);  // ddof=1 for sample variance

.. _example-floatingarray-argsort-9:

.. dropdown:: argsort (np_test_1_all.cpp:16841)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 16831
      :emphasize-lines: 11

          std::cout << "========= test_argsort =======================";
      
          // Test 1D array argsort
          NDArray<int> arr1d({ 5 });
          arr1d.setElementAt({ 0 }, 30);  // index 0
          arr1d.setElementAt({ 1 }, 10);  // index 1 
          arr1d.setElementAt({ 2 }, 40);  // index 2
          arr1d.setElementAt({ 3 }, 20);  // index 3
          arr1d.setElementAt({ 4 }, 50);  // index 4
      
          auto indices = argsort(arr1d);
      
          // Expected order: 10(idx1), 20(idx3), 30(idx0), 40(idx2), 50(idx4)
          if (!(indices.getElementAt({ 0 }) == 1)) {
              std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 0 }) == 1)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(indices.getElementAt({ 1 }) == 3)) {
              std::string description = std::string("test_argsort():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(indices.getElementAt({ 1 }) == 3)";
              std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-floatingarray-ceil-10:

.. dropdown:: ceil (np_test_2_all.cpp:5735)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5725
      :emphasize-lines: 11

                throw std::runtime_error(description);
            }
            if (!(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            // std::cout << "[OK] floor function works correctly\n";
      
            // Test ceil
            auto ceil_result = ceil(values);
            if (!(approx_equal(ceil_result.getElementAt({ 0 }), std::ceil(-2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(ceil_result.getElementAt({ 0 }), std::ceil(-2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(approx_equal(ceil_result.getElementAt({ 5 }), std::ceil(2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(ceil_result.getElementAt({ 5 }), std::ceil(2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }

.. _example-floatingarray-floor-11:

.. dropdown:: floor (np_test_2_all.cpp:5721)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 5711
      :emphasize-lines: 11

                throw std::runtime_error(description);
            }
            if (!(approx_equal(round_result.getElementAt({ 5 }), std::round(2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(round_result.getElementAt({ 5 }), std::round(2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            // std::cout << "[OK] round function works correctly\n";
      
            // Test floor
            auto floor_result = floor(values);
            if (!(approx_equal(floor_result.getElementAt({ 0 }), std::floor(-2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 0 }), std::floor(-2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))) {
                std::string description = std::string("testRoundingFunctions():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(floor_result.getElementAt({ 5 }), std::floor(2.7)))";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }

.. _example-floatingarray-round-12:

.. dropdown:: round (np_test_1_all.cpp:23769)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 23759
      :emphasize-lines: 11

                throw std::runtime_error(description);
            }
            if (!(power_scalar_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(power_scalar_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            // std::cout << "[OK] Power functions have correct signatures\n";
      
            // Test rounding functions with new decimals parameter
            auto round_result = round(array);        // Default decimals=0
            auto round_decimals_result = round(array, 2);  // With decimals
            if (!(round_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);
            }
            if (!(round_decimals_result.getShape() == array.getShape())) {
                std::string description = std::string("testMathFunctionSignatures():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(round_decimals_result.getShape() == array.getShape())";
                std::cout << std::string("[FAIL] ") + description << std::endl;
                throw std::runtime_error(description);

.. _example-floatingarray-all-13:

.. dropdown:: all (np_test_4_all.cpp:23928)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 23918
      :emphasize-lines: 11

                              }
                          }
                      }
      
                      auto result = numpy::einsum<numpy::float64>("ijk->ik", {A});
      
                      if (result.getShape()[0] != 2 || result.getShape()[1] != 2) {
                          throw std::runtime_error("einsum partial sum shape wrong");
                      }
      
                      // Sum over j: 1+2+3 = 6 for all (i,k) positions
                      if (std::abs(result.getElementAt({0, 0}) - 6.0) > 1e-10 ||
                          std::abs(result.getElementAt({1, 1}) - 6.0) > 1e-10) {
                          throw std::runtime_error("einsum partial sum values wrong");
                      }
      
                      // std::cout << "  OK: Partial sum: 'ijk->ik'\n";
                  }
      
                  // Test 5: Size-1 dimension handling
                  {

.. _example-floatingarray-any-14:

.. dropdown:: any (np_test_2_all.cpp:16758)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 16748
      :emphasize-lines: 11

          // ANY() TESTS - SCALAR RESULT
          // ============================================================================
      
          void np_test_logic_any_scalar_all_false() {
            std::cout << "========= any: all false elements =======================";
      
            // Create array with all false/zero elements
            std::vector<double> data = { 0.0, 0.0, 0.0 };
            numpy::NDArray<double> arr = numpy::createArrayFromVector<double>({ 3 }, data);
      
            bool result = numpy::any(arr);
      
            if (result != false) {
              std::cout << "  [FAIL] : in np_test_logic_any_scalar_all_false() : expected false for all-zero array";
              throw std::runtime_error("np_test_logic_any_scalar_all_false failed: expected false");
            }
      
            std::cout << " -> tests passed" << std::endl;
          }
      
          void np_test_logic_any_scalar_all_true() {

.. _example-floatingarray-isfinite-15:

.. dropdown:: isfinite (np_test_1_all.cpp:7769)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 7759
      :emphasize-lines: 11

          float16 zero(0.0f);
      
          // std::cout << "Positive infinity: " << pos_inf << std::endl;
          // std::cout << "Negative infinity: " << neg_inf << std::endl;
          // std::cout << "Quiet NaN: " << qnan << std::endl;
          // std::cout << "Zero: " << zero << std::endl;
      
          // std::cout << "Is pos_inf infinite? " << pos_inf.isinf() << std::endl;
          // std::cout << "Is neg_inf infinite? " << neg_inf.isinf() << std::endl;
          // std::cout << "Is qnan NaN? " << qnan.isnan() << std::endl;
          // std::cout << "Is zero finite? " << zero.isfinite() << std::endl;
      
          // Test NaN comparison behavior
          // std::cout << "NaN == NaN: " << (qnan == qnan) << std::endl;  // Should be false
          // std::cout << "NaN != NaN: " << (qnan != qnan) << std::endl;  // Should be true
      
          // std::cout << " -> tests passed" << std::endl;
      }
      
      void testFloat16PrecisionFloat16() {
          std::cout << "========= testFloat16PrecisionFloat16 =======================";

.. _example-floatingarray-isinf-16:

.. dropdown:: isinf (np_test_1_all.cpp:7766)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 7756
      :emphasize-lines: 11

          float16 pos_inf = float16::infinity();
          float16 neg_inf = -float16::infinity();
          float16 qnan = float16::quiet_NaN();
          float16 zero(0.0f);
      
          // std::cout << "Positive infinity: " << pos_inf << std::endl;
          // std::cout << "Negative infinity: " << neg_inf << std::endl;
          // std::cout << "Quiet NaN: " << qnan << std::endl;
          // std::cout << "Zero: " << zero << std::endl;
      
          // std::cout << "Is pos_inf infinite? " << pos_inf.isinf() << std::endl;
          // std::cout << "Is neg_inf infinite? " << neg_inf.isinf() << std::endl;
          // std::cout << "Is qnan NaN? " << qnan.isnan() << std::endl;
          // std::cout << "Is zero finite? " << zero.isfinite() << std::endl;
      
          // Test NaN comparison behavior
          // std::cout << "NaN == NaN: " << (qnan == qnan) << std::endl;  // Should be false
          // std::cout << "NaN != NaN: " << (qnan != qnan) << std::endl;  // Should be true
      
          // std::cout << " -> tests passed" << std::endl;
      }

.. _example-floatingarray-unique-17:

.. dropdown:: unique (np_test_1_all.cpp:6259)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 6249
      :emphasize-lines: 11

      
          if (!(data.size() == 100)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(data.size() == 100)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // Count unique values
          std::vector<int> sorted_copy = data;
          std::sort(sorted_copy.begin(), sorted_copy.end());
          auto unique_end = std::unique(sorted_copy.begin(), sorted_copy.end());
          size_t unique_count = std::distance(sorted_copy.begin(), unique_end);
      
          // Should have significantly fewer unique values than total elements
          if (!(unique_count < data.size() / 2)) {
              std::string description = std::string("test_data_generator_few_uniqueBenchmarkSorting():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(unique_count < data.size() / 2)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // std::cout << "Few unique data generation test passed. Unique values: " << unique_count << std::endl;

.. _example-floatingarray-to_numpy-18:

.. dropdown:: to_numpy (np_test_5_all.cpp:21373)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 21363
      :emphasize-lines: 11

          if (errors == 0) {
              std::cout << "np_test_timedelta_components -> tests passed" << std::endl;
          }
          return errors;
      }
      
      // =============================================================================
      // Test 4: Total Conversion Properties
      // =============================================================================
      int np_test_timedelta_total_conversions() {
          int errors = 0;
      
          numpy::Timedelta td(1, 12, 0);  // 1 day 12 hours = 1.5 days = 36 hours
      
          // total_seconds
          {
              double secs = td.total_seconds();
              double expected = (24 + 12) * 3600.0;
              if (std::abs(secs - expected) > 0.0001) {
                  std::cout << "[FAIL] np_test_timedelta_total_conversions: total_seconds expected "
                            << expected << ", got " << secs << std::endl;

.. _example-floatingarray-to_string-19:

.. dropdown:: to_string (np_test_1_all.cpp:454)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 444
      :emphasize-lines: 11

          // Modify through different views
          view1.setElementAt({0, 0}, 100);
          view2.setElementAt({2, 1}, 200);  // This is (1, 2) in original
          view3.setElementAt({0, 0}, 300);  // This is (1, 1) in original
      
          // std::cout << "After modifications through multiple views:" << std::endl;
          //original.printArray();
      
          // Verify all changes are reflected
          if (!(original.getElementAt({0, 0}) == 100)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({0, 0}) == 100)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(original.getElementAt({1, 2}) == 200)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 2}) == 200)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(original.getElementAt({1, 1}) == 300)) {
              std::string description = std::string("testAdvancedViewLifecycle():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 300)";

.. _example-floatingarray-copy-20:

.. dropdown:: copy (np_test_1_all.cpp:9812)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 9802
      :emphasize-lines: 11

          //original.printArray();
      
          // The modification should be at position (1,1) in original
          if (!(original.getElementAt({1, 1}) == 9999)) {
              std::string description = std::string("testSliceCopyVsViewMemoryOwnership():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(original.getElementAt({1, 1}) == 9999)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] Slice view shares memory with original";
      
          // Test slice copy (should be independent)
          auto slice_copy = original.sliceArray({{2, 4}, {2, 4}});
          // std::cout << "Slice copy [2:4, 2:4]:";
          //slice_copy.printArray();
      
          slice_copy.setElementAt({0, 0}, 7777);
      
          // std::cout << "After modifying slice copy at (0,0):" << std::endl;
          // std::cout << "Original array:" << std::endl;
          //original.printArray();
          // std::cout << "Slice copy:" << std::endl;

.. _example-floatingarray-argmax-21:

.. dropdown:: argmax (np_test_3_all.cpp:20521)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 20511
      :emphasize-lines: 11

      
          auto result = numpy::argmin(arr);
          // Should return 1 (index of (1,5))
          if (result.getElementAt({0}) != 1) {
              throw std::runtime_error("argmin() failed: expected index 1");
          }
          std::cout << "PASSED\n";
      }
      
      void test_argmax_complex128() {
          std::cout << "  Testing argmax() with complex128... ";
          numpy::NDArray<complex128> arr({3});
          arr.setElementAt({0}, complex128(3.0, 1.0));  // index 0 - largest
          arr.setElementAt({1}, complex128(1.0, 5.0));  // index 1
          arr.setElementAt({2}, complex128(2.0, 2.0));  // index 2
      
          auto result = numpy::argmax(arr);
          // Should return 0 (index of (3,1))
          if (result.getElementAt({0}) != 0) {
              throw std::runtime_error("argmax() failed: expected index 0");
          }

.. _example-floatingarray-argmin-22:

.. dropdown:: argmin (np_test_3_all.cpp:20506)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 20496
      :emphasize-lines: 11

          if (min_result.getElementAt({0}).real() != 2.0 || min_result.getElementAt({0}).imag() != 1.0) {
              throw std::runtime_error("min() tie-breaking failed: expected (2,1)");
          }
          if (max_result.getElementAt({0}).real() != 2.0 || max_result.getElementAt({0}).imag() != 5.0) {
              throw std::runtime_error("max() tie-breaking failed: expected (2,5)");
          }
          std::cout << "PASSED\n";
      }
      
      void test_argmin_complex128() {
          std::cout << "  Testing argmin() with complex128... ";
          numpy::NDArray<complex128> arr({3});
          arr.setElementAt({0}, complex128(3.0, 1.0));  // index 0
          arr.setElementAt({1}, complex128(1.0, 5.0));  // index 1 - smallest
          arr.setElementAt({2}, complex128(2.0, 2.0));  // index 2
      
          auto result = numpy::argmin(arr);
          // Should return 1 (index of (1,5))
          if (result.getElementAt({0}) != 1) {
              throw std::runtime_error("argmin() failed: expected index 1");
          }

.. _example-floatingarray-count-23:

.. dropdown:: count (np_test_1_all.cpp:3616)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3606
      :emphasize-lines: 11

          // Create larger arrays for performance testing
          auto large_arr = NDArray<double>::createOnes({100, 100});
          auto broadcast_arr = NDArray<double>::createOnes({1, 100});
      
          // Time the operation (basic timing)
          auto start = std::chrono::high_resolution_clock::now();
          auto result = large_arr.addArrays(broadcast_arr);
          auto end = std::chrono::high_resolution_clock::now();
      
          auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
          // std::cout << "Large array broadcasting took " << duration.count() << " microseconds" << std::endl;
      
          // Verify result shape
          if (!((result.getShape() == std::vector<size_t>{100, 100}))) {
              std::string description = std::string("test_broadcasting_performance():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !((result.getShape() == std::vector<size_t>{100, 100}))";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(result.getElementAt({50, 50}) == 2.0)) {
              std::string description = std::string("test_broadcasting_performance():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(result.getElementAt({50, 50}) == 2.0)";
              std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-floatingarray-data-24:

.. dropdown:: data (np_test_1_all.cpp:2084)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 2074
      :emphasize-lines: 11

          }
          if (!(derived_ptr->extra == 2)) {
              std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(derived_ptr->extra == 2)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
      
          // Test 6: Large object handling
          struct LargeObject {
              std::vector<double> data;
              LargeObject() : data(10000, 3.14159) {}  // Large object
          };
      
          LargeObject large;
          object_ large_obj(large);  // Should handle large objects
          if (!(!large_obj.is_null())) {
              std::string description = std::string("testObjectHolderEdgeCases():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(!large_obj.is_null())";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          if (!(large_obj.is_type<LargeObject>())) {

.. _example-floatingarray-dtype-25:

.. dropdown:: dtype (np_test_3_all.cpp:7942)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 7932
      :emphasize-lines: 11

        if (info.max != expected_max) {
          std::cerr << "[FAIL] IInfo<uint64_t>::max mismatch";
          throw std::runtime_error("IInfo uint64 max test failed");
        }
        // std::cout << "[OK] IInfo<uint64_t>::max = " << info.max << std::endl;
      
        std::cout << " -> tests passed" << std::endl;
      }
      
      // ============================================================================
      // dtype() Tests - DType descriptor creation
      // ============================================================================
      
      void np_test_dtype_from_string_integers() {
        std::cout << "========= np_test_dtype_from_string_integers =======================";
      
        // Test integer type strings
        if (dtype("int8") != DType::INT8) {
          std::cerr << "[FAIL] dtype(\"int8\") should return INT8";
          throw std::runtime_error("dtype string test failed");
        }

.. _example-floatingarray-mask-26:

.. dropdown:: mask (np_test_1_all.cpp:27691)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 27681
      :emphasize-lines: 11

          void test_mask_rows_cols() {
            std::cout << "========= ma::mask_rows() and ma::mask_cols(): mask operations ===";
      
            auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0} });
            auto mask = numpy::array({ {false, true, false}, {false, false, false} });
            auto ma = numpy::ma::masked_array(data, mask);
      
            auto result_rows = numpy::ma::mask_rows(ma);
            auto result_cols = numpy::ma::mask_cols(ma);
      
            // std::cout << "  ma::mask_rows(): row 0 fully masked: " << (result_rows.mask().getElementAt({ 0, 0 }) ? "true" : "false") << std::endl;
            // std::cout << "  ma::mask_cols(): column 1 fully masked: " << (result_cols.mask().getElementAt({ 1, 1 }) ? "true" : "false");
            std::cout << " -> tests passed";
          }
      
          void test_compress_rowcols() {
            std::cout << "========= ma::compress_rowcols(): remove masked rows/columns ===";
      
            auto data = numpy::array({ {1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0} });
            auto mask = numpy::array({ {false, false, false}, {false, true, false}, {false, false, false} });
            auto ma = numpy::ma::masked_array(data, mask);

.. _example-floatingarray-nbytes-27:

.. dropdown:: nbytes (np_test_2_all.cpp:3547)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3537
      :emphasize-lines: 11

            }
      
            // 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);
            }
      
            // Test flags
            auto flags_info = flags(arr);
            if (!(flags_info.owndata == true)) {
                std::string description = std::string("testArrayInfo():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(flags_info.owndata == true)";
                std::cout << std::string("[FAIL] ") + description << std::endl;

.. _example-floatingarray-ndim-28:

.. dropdown:: ndim (np_test_2_all.cpp:3526)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3516
      :emphasize-lines: 11

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

.. _example-floatingarray-prod-29:

.. dropdown:: prod (np_test_1_all.cpp:11795)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 11785
      :emphasize-lines: 11

              throw std::runtime_error(description);
          }
          // std::cout << "[OK] min and max work correctly\n";
      
          // Test product
          auto small_array = createInt32Array({ 3 }, 0);
          small_array.setElementAt({ 0 }, 2);
          small_array.setElementAt({ 1 }, 3);
          small_array.setElementAt({ 2 }, 4);
      
          auto prod_result = prod(small_array);
          if (!(prod_result.getElementAt({ 0 }) == 24)) {
              std::string description = std::string("testBasicStatistics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(prod_result.getElementAt({ 0 }) == 24)";
              std::cout << std::string("[FAIL] ") + description << std::endl;
              throw std::runtime_error(description);
          }
          // std::cout << "[OK] prod works correctly\n";
          std::cout << " -> tests passed" << std::endl;
        }
      
        void testVarianceAndStandardDeviation() {

.. _example-floatingarray-shape-30:

.. dropdown:: shape (np_test_1_all.cpp:3751)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 3741
      :emphasize-lines: 11

          }
      
          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)) {

.. _example-floatingarray-size-31:

.. dropdown:: size (np_test_1_all.cpp:47)
   :class-title: example-dropdown

   .. code-block:: cpp
      :linenos:
      :lineno-start: 37
      :emphasize-lines: 11

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