NumPy dtype and Memory Layout — float32, int64 and C vs F order

import numpy as np

# Check dtype and itemsize
a = np.array([1.0, 2.0, 3.0])
print(a.dtype)    # float64
print(a.itemsize) # 8 bytes per element

b = np.array([1.0, 2.0, 3.0], dtype=np.float32)
print(b.dtype)    # float32
print(b.itemsize) # 4 bytes — half the memory

# Integer types
c = np.array([1, 2, 3], dtype=np.int8)   # 1 byte, range -128 to 127
d = np.array([1, 2, 3], dtype=np.uint8)  # 1 byte, range 0 to 255 (pixel values)
e = np.array([1, 2, 3], dtype=np.int32)  # 4 bytes

# Memory usage
large = np.ones((1000, 1000))
print(large.nbytes)  # 8,000,000 bytes (8MB, float64)
print(large.astype(np.float32).nbytes)  # 4,000,000 bytes (4MB)

import numpy as np
import time

m = np.random.randn(5000, 5000)

# C-order (default) — rows are contiguous
c_arr = np.ascontiguousarray(m)  # ensure C-order
f_arr = np.asfortranarray(m)     # column-major

# Row sum: faster in C-order (row traversal)
start = time.time()
_ = c_arr.sum(axis=1)
print(f'C-order row sum: {time.time()-start:.4f}s')

start = time.time()
_ = f_arr.sum(axis=1)
print(f'F-order row sum: {time.time()-start:.4f}s')

print(c_arr.flags['C_CONTIGUOUS'])  # True
print(f_arr.flags['F_CONTIGUOUS'])  # True

import numpy as np

arr = np.array([1.9, 2.7, 3.1])

# astype creates a copy with new dtype
ints = arr.astype(np.int32)  # truncates: [1, 2, 3]
print(ints)  # [1 2 3]

# View as different dtype (reinterpret bytes — advanced)
bytes_view = arr.view(np.uint8)
print(bytes_view.shape)  # (24,) — 3 float64s × 8 bytes each

package io.thecodeforge.service;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

/**
 * Manages the hand-off between high-performance NumPy binaries 
 * and Java-based microservices using direct memory mapping.
 */
public class DataIngestionService {

    public void processNumPyBinary(byte[] rawData) {
        // Production logic for handling float32 vs float64 buffers
        // In a real forge, we'd use Project Panama (Foreign Function Interface)
        // to map this memory directly without heap allocation overhead.
        System.out.println("Processing incoming binary stream of " + rawData.length + " bytes");
    }

    public static void main(String[] args) throws IOException {
        DataIngestionService service = new DataIngestionService();
        service.processNumPyBinary(new byte[4000000]); // Simulating 1M float32 elements
    }
}

# Optimized Dockerfile for memory-efficient NumPy workloads
FROM python:3.11-slim

LABEL maintainer="engineering@thecodeforge.io"

WORKDIR /app

# Install build essentials for C-extensions
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# Use environment variables to tune OpenBLAS for C/F order optimization
ENV OPENBLAS_NUM_THREADS=4

CMD ["python", "process_data.py"]