[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

.augment/rules/update-python.md

@@ -20,4 +20,4 @@ I will provide you with two folders shortly. I need you to systematically update
 5. **Consistency**: Ensure naming conventions and documentation style are consistent across all binding files
 6. **Error Handling**: Properly handle C++ exceptions and convert them to appropriate Python exceptions
 
-Please work through each module systematically, and let me know when you've completed each one so I can review the changes before proceeding to the next module.
+Please work through each module systematically, and let me know when you've completed each one so I can review the changes before proceeding to the next module.

.claude/settings.local.json

@@ -29,4 +29,4 @@
     "deny": [],
     "ask": []
   }
-}
+}

CLAUDE.md

@@ -121,4 +121,4 @@ ctest -R "algorithm_*" --output-on-failure
 ### Building with All Features
 ```bash
 ./scripts/build.sh --release --python --examples --tests --docs --package
-```
+```

atom/algorithm/core/opencl_utils.cpp

@@ -16,101 +16,101 @@ auto Platform::getPlatforms() -> std::vector<cl_platform_id> {
     if (err != CL_SUCCESS || num_platforms == 0) {
         return {};
     }
-    
+
     std::vector<cl_platform_id> platforms(num_platforms);
     err = clGetPlatformIDs(num_platforms, platforms.data(), nullptr);
     if (err != CL_SUCCESS) {
         return {};
     }
-    
+
     return platforms;
 }
 
 auto Platform::getDevices(cl_platform_id platform, DeviceType device_type) -> std::vector<cl_device_id> {
     cl_uint num_devices;
-    cl_int err = clGetDeviceIDs(platform, static_cast<cl_device_type>(device_type), 
+    cl_int err = clGetDeviceIDs(platform, static_cast<cl_device_type>(device_type),
                                0, nullptr, &num_devices);
     if (err != CL_SUCCESS || num_devices == 0) {
         return {};
     }
-    
+
     std::vector<cl_device_id> devices(num_devices);
-    err = clGetDeviceIDs(platform, static_cast<cl_device_type>(device_type), 
+    err = clGetDeviceIDs(platform, static_cast<cl_device_type>(device_type),
                         num_devices, devices.data(), nullptr);
     if (err != CL_SUCCESS) {
         return {};
     }
-    
+
     return devices;
 }
 
 auto Platform::getDeviceInfo(cl_device_id device) -> DeviceInfo {
     DeviceInfo info;
-    
+
     // Get device name
     usize name_size;
     clGetDeviceInfo(device, CL_DEVICE_NAME, 0, nullptr, &name_size);
     std::string name(name_size, '\0');
     clGetDeviceInfo(device, CL_DEVICE_NAME, name_size, name.data(), nullptr);
     info.name = name.c_str(); // Remove null terminator
-    
+
     // Get vendor
     usize vendor_size;
     clGetDeviceInfo(device, CL_DEVICE_VENDOR, 0, nullptr, &vendor_size);
     std::string vendor(vendor_size, '\0');
     clGetDeviceInfo(device, CL_DEVICE_VENDOR, vendor_size, vendor.data(), nullptr);
     info.vendor = vendor.c_str();
-    
+
     // Get version
     usize version_size;
     clGetDeviceInfo(device, CL_DEVICE_VERSION, 0, nullptr, &version_size);
     std::string version(version_size, '\0');
     clGetDeviceInfo(device, CL_DEVICE_VERSION, version_size, version.data(), nullptr);
     info.version = version.c_str();
-    
+
     // Get device type
     cl_device_type type;
     clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(type), &type, nullptr);
     info.type = static_cast<DeviceType>(type);
-    
+
     // Get compute units
     cl_uint compute_units;
     clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(compute_units), &compute_units, nullptr);
     info.max_compute_units = compute_units;
-    
+
     // Get max work group size
     usize work_group_size;
     clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(work_group_size), &work_group_size, nullptr);
     info.max_work_group_size = work_group_size;
-    
+
     // Get global memory size
     cl_ulong global_mem_size;
     clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(global_mem_size), &global_mem_size, nullptr);
     info.global_memory_size = global_mem_size;
-    
+
     // Get local memory size
     cl_ulong local_mem_size;
     clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(local_mem_size), &local_mem_size, nullptr);
     info.local_memory_size = local_mem_size;
-    
+
     // Check double precision support
     usize extensions_size;
     clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS, 0, nullptr, &extensions_size);
     std::string extensions(extensions_size, '\0');
     clGetDeviceInfo(device, CL_DEVICE_EXTENSIONS, extensions_size, extensions.data(), nullptr);
     info.supports_double = extensions.find("cl_khr_fp64") != std::string::npos;
-    
+
     return info;
 }
 
 auto Platform::createContext(const std::vector<cl_device_id>& devices) -> Context {
     cl_int err;
-    cl_context context = clCreateContext(nullptr, static_cast<cl_uint>(devices.size()), 
+    cl_context context = clCreateContext(nullptr, static_cast<cl_uint>(devices.size()),
                                         devices.data(), nullptr, nullptr, &err);
     if (err != CL_SUCCESS) {
         THROW_RUNTIME_ERROR("Failed to create OpenCL context: error {}", err);
     }
-    
+
     return Context(context);
 }
 
@@ -120,18 +120,18 @@ auto Platform::createCommandQueue(const Context& context, cl_device_id device) -
     if (err != CL_SUCCESS) {
         THROW_RUNTIME_ERROR("Failed to create OpenCL command queue: error {}", err);
     }
-    
+
     return CommandQueue(queue);
 }
 
 auto Platform::createBuffer(const Context& context, MemoryFlags flags, usize size, void* host_ptr) -> Buffer {
     cl_int err;
-    cl_mem buffer = clCreateBuffer(context.get(), static_cast<cl_mem_flags>(flags), 
+    cl_mem buffer = clCreateBuffer(context.get(), static_cast<cl_mem_flags>(flags),
                                   size, host_ptr, &err);
     if (err != CL_SUCCESS) {
         THROW_RUNTIME_ERROR("Failed to create OpenCL buffer: error {}", err);
     }
-    
+
     return Buffer(buffer);
 }
 
@@ -141,56 +141,56 @@ auto Platform::buildKernel(const Context& context,
                           const std::string& kernel_name,
                           const std::string& build_options) -> Kernel {
     cl_int err;
-    
+
     // Create program from source
     const char* source_ptr = source.c_str();
     usize source_size = source.length();
     cl_program program = clCreateProgramWithSource(context.get(), 1, &source_ptr, &source_size, &err);
     if (err != CL_SUCCESS) {
         THROW_RUNTIME_ERROR("Failed to create OpenCL program: error {}", err);
     }
-    
+
     // Build program
-    err = clBuildProgram(program, static_cast<cl_uint>(devices.size()), devices.data(), 
+    err = clBuildProgram(program, static_cast<cl_uint>(devices.size()), devices.data(),
                         build_options.empty() ? nullptr : build_options.c_str(), nullptr, nullptr);
-    
+
     if (err != CL_SUCCESS) {
         // Get build log for debugging
         usize log_size;
         clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size);
         std::string build_log(log_size, '\0');
         clGetProgramBuildInfo(program, devices[0], CL_PROGRAM_BUILD_LOG, log_size, build_log.data(), nullptr);
-        
+
         clReleaseProgram(program);
         THROW_RUNTIME_ERROR("Failed to build OpenCL program: error {}\nBuild log: {}", err, build_log);
     }
-    
+
     // Create kernel
     cl_kernel kernel = clCreateKernel(program, kernel_name.c_str(), &err);
     clReleaseProgram(program); // Release program as kernel holds reference
-    
+
     if (err != CL_SUCCESS) {
         THROW_RUNTIME_ERROR("Failed to create OpenCL kernel '{}': error {}", kernel_name, err);
     }
-    
+
     return Kernel(kernel);
 }
 
 auto ComputeManager::initialize(DeviceType preferred_type) -> bool {
     if (initialized_) {
         return true;
     }
-    
+
     try {
         auto platforms = Platform::getPlatforms();
         if (platforms.empty()) {
             return false;
         }
-        
+
         // Try to find a device of the preferred type
         cl_device_id best_device = nullptr;
         std::vector<cl_device_id> context_devices;
-        
+
         for (auto platform : platforms) {
             auto devices = Platform::getDevices(platform, preferred_type);
             if (!devices.empty()) {
@@ -199,7 +199,7 @@ auto ComputeManager::initialize(DeviceType preferred_type) -> bool {
                 break;
             }
         }
-        
+
         // If preferred type not found, try any device
         if (!best_device) {
             for (auto platform : platforms) {
@@ -211,20 +211,20 @@ auto ComputeManager::initialize(DeviceType preferred_type) -> bool {
                 }
             }
         }
-        
+
         if (!best_device) {
             return false;
         }
-        
+
         // Create context and command queue
         context_ = Platform::createContext(context_devices);
         queue_ = Platform::createCommandQueue(context_, best_device);
         device_ = best_device;
         device_info_ = Platform::getDeviceInfo(best_device);
-        
+
         initialized_ = true;
         return true;
-        
+
     } catch (const std::exception&) {
         return false;
     }