MemoryMapper

class numpy::MemoryMapper

numpy C++ class.

Example

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

// Use MemoryMapper
MemoryMapper obj;
// ... operations ...

Type Checking

Signature	Return Type	Location	Example
bool is_open()	bool	NP_MEMMAP.H:270	View

Other Methods

Signature	Return Type	Location	Example
void close()	void	NP_MEMMAP.H:235	View
void \* data()	void *	NP_MEMMAP.H:268	View
void flush()	void	NP_MEMMAP.H:219	View
void \* map(const std::string &filename, size_tsize, size_toffset, MMapModemode)	void *	NP_MEMMAP.H:203
void \* map_posix(const std::string &filename, size_tsize, size_toffset, MMapModemode)	void *	NP_MEMMAP.H:420
void \* map_windows(const std::string &filename, size_tsize, size_toffset, MMapModemode)	void *	NP_MEMMAP.H:274
size_t size()	size_t	NP_MEMMAP.H:269	View

Code Examples

The following examples are extracted from the test suite.

is_open (np_test_3_all.cpp:11184)

      mmap1.setElementAt({ 1, 1 }, 42);
      mmap1.flush();

      // Move constructor
      auto mmap2 = std::move(mmap1);
      if (!(mmap2.getElementAt({ 1, 1 }) == 42)) {
          std::string description = std::string("np_test_io_memmap_move_semantics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mmap2.getElementAt({ 1, 1 }) == 42)";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      if (!(mmap2.is_open())) {
          std::string description = std::string("np_test_io_memmap_move_semantics():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(mmap2.is_open())";
          std::cout << std::string("[FAIL] ") + description << std::endl;
          throw std::runtime_error(description);
      }
      // std::cout << "[OK] Move constructor works" << std::endl;

      // Move assignment
      auto mmap3 = memmap::memmap<int32_t>(filename, { 3, 3 }, "r+");
      mmap3 = std::move(mmap2);
      if (!(mmap3.getElementAt({ 1, 1 }) == 42)) {

close (np_test_1_all.cpp:26157)

    void np_test_recarray_fromfile() {
      std::cout << "========= fromfile: create RecordArray from file =======================";

      // Create temporary test file
      std::string filename = "D:/Projects/Cpp2/temp/test_recarray.csv";
      std::ofstream outfile(filename);
      outfile << "1,10.5\n";
      outfile << "2,20.5\n";
      outfile << "3,30.5\n";
      outfile.close();

      // Define dtype
      std::vector<std::pair<std::string, numpy::DType>> fields = {
          {"id", numpy::DType::INT32},
          {"value", numpy::DType::FLOAT64}
      };
      auto dtype = std::make_shared<numpy::StructuredDType>(fields);

      // Load from file
      auto result = numpy::fromfile(filename, dtype, ",");

data (np_test_1_all.cpp:2084)

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

flush (np_test_2_all.cpp:10646)

      std::vector<size_t> shape = { 10, 5 };
      auto mmap_array = numpy::memmap::memmap<float>(TEMP_DIR + "test_memmap_new.npy", shape, "w+");

      // Write some data
      for (size_t i = 0; i < 10; ++i) {
        for (size_t j = 0; j < 5; ++j) {
          mmap_array.setElementAt({ i, j }, static_cast<float>(i * 5 + j + 1));
        }
      }

      mmap_array.flush();
      // std::cout << "[OK] Created and wrote to memory-mapped file\n";

      // Test reading from existing memory-mapped file
      auto mmap_readonly = numpy::memmap::memmap<float>(TEMP_DIR + "test_memmap_new.npy", shape, "r");

      for (size_t i = 0; i < 10; ++i) {
        for (size_t j = 0; j < 5; ++j) {
          float expected = static_cast<float>(i * 5 + j + 1);
          if (!(approx_equal(mmap_readonly.getElementAt({ i, j }), expected, 1e-6f))) {
              std::string description = std::string("testMemoryMapping():") + __FILE__ + ":" + std::to_string(__LINE__) + ": !(approx_equal(mmap_readonly.getElementAt({ i, j }), expected, 1e-6f))";

size (np_test_1_all.cpp:47)

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

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

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

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