integration 0.1.1 → 0.1.2

data/lib/integration/version.rb

@@ -0,0 +1,3 @@
+class Integration
+  VERSION = '0.1.2'
+end

data/lib/opencl/Makefile

@@ -0,0 +1,29 @@
+all: cl.so
+
+CC=gcc
+CL_HEADERS_PATH=
+LIBOPENCL_PATH=
+
+
+UNAME := $(shell uname)
+ifeq ($(UNAME), Linux)
+# do something Linux-y
+OPENCL_LIBRARY_CALL=-lOpenCL
+endif
+ifeq ($(UNAME), Solaris)
+# do something Solaris-y
+OPENCL_LIBRARY_CALL=-framework OpenCL
+endif
+
+
+
+cl.so: integration_host.o
+	$(CC) -shared -o cl.so integration_host.o -I $(CL_HEADERS_PATH) -L $(LIBOPENCL_PATH) $(OPENCL_LIBRARY_CALL)
+
+
+integration_host.o: integration_host.c
+	$(CC) -fpic -c integration_host.c
+
+clean:
+	rm cl.so integration_host.o
+

data/lib/opencl/integration_host.c

@@ -0,0 +1,151 @@
+// This file contains the host code of the openCL supported integration
+#include <stdio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+#include <limits.h>       //For PATH_MAX
+
+// import OpenCL headers assuming OS is a linux version or MAC
+#ifdef __APPLE__
+    #include<OpenCL/opencl.h>
+#else
+    #include<CL/cl.h>
+#endif
+
+#define MAX_SOURCE_SIZE (0x100000) // maximum size allowed for the kernel text
+
+// these are the available integration methods
+enum methods{
+      rectangle,
+      trapezoid,
+      simpson,
+      adaptive_quadrature,
+      gauss,
+      romberg,
+      monte_carlo
+};
+
+double opencl_integration(double lower, double upper, int n, char* f,
+                        enum methods method, char* path_to_kerne) {
+
+    char* source_str;
+    size_t source_size;
+    int i = 0;
+    double dx = (upper - lower) / n;
+    double *results = (double*) malloc(n * sizeof(double));
+
+    // read the corresponding kernel
+    FILE* fp;
+    sprintf(path_to_kerne, "%s%s", path_to_kerne, "/unidimensional_kernel.cl");
+    fp = fopen(path_to_kerne, "r");
+
+    // if the kernel file doesn't exist, stop the execution
+    if(fp == 0) {
+        printf("kernel file not found\n");
+        exit(0);
+    }
+    
+    char *temp_source;
+    // allocate memory for kenel code
+    temp_source = (char*) malloc(sizeof(char) * MAX_SOURCE_SIZE);
+    source_str  = (char*) malloc(sizeof(char) * MAX_SOURCE_SIZE);
+
+    temp_source[0] = '\0';  // make temp_source a null string
+    char line[100];
+    // read the text of the kernel into temp_source
+    while(!feof(fp)) {
+        if (fgets(line, 100, fp)) {
+            sprintf(temp_source, "%s%s",temp_source, line);
+        }
+    }
+
+    // create the complete kernel code appending,
+    // f()   - integrating function
+    sprintf(source_str, "double f(double x){return (%s);}\n%s", f, temp_source);
+
+    // printf("\nfunction----------------------------\n%s\n--------------------------\n", source_str);
+    source_size = strlen(source_str);
+    fclose(fp);
+    free(temp_source);
+
+    cl_platform_id platform_id = NULL;
+    cl_device_id device_id     = NULL;   
+    cl_uint ret_num_devices;
+    cl_uint ret_num_platforms;
+    cl_int ret;
+    ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
+    // CL_DEVICE_TYPE_CPU is being used currently as the testing value
+    ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_CPU, 1, &device_id, &ret_num_devices);
+
+    // create kernel
+    cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
+    // create command queue
+    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret);    
+
+    // create memory buffers to share memory with kernel program 
+    cl_mem lower_obj  = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(double)     , NULL, &ret);
+    cl_mem dx_obj     = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(double)     , NULL, &ret);
+    cl_mem n_obj      = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(int)       , NULL, &ret);
+    cl_mem method_obj = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(int)       , NULL, &ret);
+    cl_mem result_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(double) * n , NULL, &ret);
+    //cl_mem epsilon_obj      = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(double)     , NULL, &ret);
+    //cl_mem golden_obj       = clCreateBuffer(context, CL_MEM_READ_ONLY,  sizeof(double)     , NULL, &ret);
+
+    // writes the input values into the allocated memory buffers
+    ret = clEnqueueWriteBuffer(command_queue, lower_obj,  CL_TRUE, 0, sizeof(double)    , &lower , 0, NULL, NULL);
+    ret = clEnqueueWriteBuffer(command_queue, dx_obj   ,  CL_TRUE, 0, sizeof(double)    , &dx    , 0, NULL, NULL);
+    ret = clEnqueueWriteBuffer(command_queue, n_obj    ,  CL_TRUE, 0, sizeof(int)      , &n     , 0, NULL, NULL);
+    ret = clEnqueueWriteBuffer(command_queue, method_obj, CL_TRUE, 0, sizeof(int)      , &method, 0, NULL, NULL);
+    //ret = clEnqueueWriteBuffer(command_queue, epsilon_obj , CL_TRUE, 0, sizeof(double)    , &epsilon       , 0, NULL, NULL);
+    //ret = clEnqueueWriteBuffer(command_queue, golden_obj  , CL_TRUE, 0, sizeof(double)    , &golden        , 0, NULL, NULL);
+
+    // create kernel program
+    cl_program program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret);
+    // build the kernel program. Still the code isn't being executed
+    // memory buffers haven't involved. Any error at this stage MAY be a syntax error of kernel code
+    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
+    // this gives error message only if the kernel code includes any syntax error
+    if(ret == CL_BUILD_PROGRAM_FAILURE)  printf("\nerror while building kernel: %d\n", ret);
+    // create the kernel calling the kernel function 'minimize'
+    cl_kernel kernel = clCreateKernel(program, "integrate", &ret);
+
+    // set arguments of kernel function
+    ret = clSetKernelArg(kernel, 0 , sizeof(cl_mem)    , (void *)&lower_obj);    
+    ret = clSetKernelArg(kernel, 1 , sizeof(cl_mem)    , (void *)&dx_obj);    
+    ret = clSetKernelArg(kernel, 2 , sizeof(cl_mem)    , (void *)&n_obj);    
+    ret = clSetKernelArg(kernel, 3 , sizeof(cl_mem)    , (void *)&method_obj);    
+    ret = clSetKernelArg(kernel, 4 , sizeof(cl_mem) * n, (void *)&result_obj);
+    //ret = clSetKernelArg(kernel, 9 , sizeof(cl_mem)    , (void *)&epsilon_obj);
+    //ret = clSetKernelArg(kernel, 10, sizeof(cl_mem)    , (void *)&golden_obj);
+
+    size_t global_item_size = n;
+    // enqueue the jobs and let them to be solved by kernel program
+    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_item_size, NULL, 0, NULL, NULL);
+    
+    // retrieve results from the shared memory buffers
+    ret = clEnqueueReadBuffer(command_queue, result_obj, CL_TRUE, 0, sizeof(double) * n, results, 0, NULL, NULL);
+
+    // clear the allocated memory
+    ret = clFlush(command_queue);
+    ret = clFinish(command_queue);
+    ret = clReleaseKernel(kernel);
+    ret = clReleaseProgram(program);
+
+    ret = clReleaseMemObject(lower_obj);
+    ret = clReleaseMemObject(dx_obj);
+    ret = clReleaseMemObject(n_obj);
+    ret = clReleaseMemObject(method_obj);
+    //ret = clReleaseMemObject(epsilon_obj);
+    //ret = clReleaseMemObject(golden_obj);
+
+    ret = clReleaseCommandQueue(command_queue);
+    ret = clReleaseContext(context);
+    free(source_str);
+
+    double final_result = 0;
+    for(i = 0; i < n; ++i) {
+        final_result += results[i];
+    }
+
+    return final_result;
+}

data/lib/opencl/opencl_minimization.rb

@@ -0,0 +1,251 @@
+require 'ffi'
+
+module OpenCLMinimization extend FFI::Library
+
+  MAX_ITERATIONS_DEFAULT = 100000
+  EPSILON_DEFAULT        = 0.00001
+  GOLDEN_DEFAULT         = 0.3819660
+  SQRT_EPSILON_DEFAULT   = 0.00001
+  PATH_TO_KERNEL = File.expand_path(File.dirname(__FILE__))
+
+  ffi_lib "#{File.expand_path(File.dirname(__FILE__))}/cl.so"
+
+  # attack with the opencl_minimize of min_host.c
+  attach_function 'opencl_minimize', [:int, :pointer, :pointer, :pointer, :int, :string, :string,
+                                     :string, :pointer, :pointer, :int, :int, :float, :float, :float, :string], :void
+
+  # Classic GodlSectionMinimizer minimization method.  
+  # Basic minimization algorithm. Slow, but robust.
+  # See Unidimensional for methods.
+  # == Usage
+  #  n              = 3
+  #  start_point    = [1, 3, 5]
+  #  expected_point = [1.5, 3.5, 5.5]
+  #  end_point      = [3, 5, 7]
+  #  f              = "pow((x-2)*(x-4)*(x-6), 2)+1"
+  #  min = OpenCLMinimization::GodlSectionMinimizer.new(n, start_point, expected_point, end_point, f)
+  #  min.minimize
+  #  min.x_minimum
+  #  min.f_minimum   
+  #
+  class GodlSectionMinimizer
+    attr_reader :x_minimum
+    attr_reader :f_minimum
+
+    attr_writer :max_iterations
+    attr_writer :epsilon
+    attr_writer :golden
+
+    # == Parameters:
+    # * <tt>n</tt>: Number of Jobs
+    # * <tt>start_point</tt>: Lower possible value
+    # * <tt>expected_point</tt>: Initial point
+    # * <tt>end_point</tt>: Higher possible value
+    # * <tt>f</tt>: Original function string
+    #
+    def initialize(n, start_point, expected_point, end_point, f)
+      @n              = n
+      @start_point    = start_point
+      @expected_point = expected_point
+      @end_point      = end_point
+      @f              = f
+      @max_iterations = MAX_ITERATIONS_DEFAULT
+      @epsilon        = EPSILON_DEFAULT
+      @golden         = GOLDEN_DEFAULT
+      @sqrt_epsilon   = SQRT_EPSILON_DEFAULT
+    end
+
+    def minimize
+      # create Buffers for inputs and outputs
+      start_buffer    = FFI::Buffer.alloc_inout(:pointer, @n)
+      expected_buffer = FFI::Buffer.alloc_inout(:pointer, @n)
+      end_buffer      = FFI::Buffer.alloc_inout(:pointer, @n)
+      x_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+      f_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+
+      # set inputs
+      start_buffer.write_array_of_float(@start_point)
+      expected_buffer.write_array_of_float(@expected_point)
+      end_buffer.write_array_of_float(@end_point)
+
+      # call minimizer
+      OpenCLMinimization::opencl_minimize(@n, start_buffer, expected_buffer, end_buffer, 0, @f, "", "", x_buffer,
+                                          f_buffer, 0, @max_iterations, @epsilon, @golden, @sqrt_epsilon, PATH_TO_KERNEL)
+
+      @x_minimum = Array.new(@n)
+      @f_minimum = Array.new(@n)
+      # read results
+      @x_minimum = x_buffer.read_array_of_float(@n)
+      @f_minimum = f_buffer.read_array_of_float(@n)
+    end
+    end
+
+  # Classic Newton-Raphson minimization method.  
+  # Requires first and second derivative
+  # == Usage
+  #  n              = 3
+  #  expected_point = [1, 100, 1000]
+  #  f              = "(x-3)*(x-3)+5"
+  #  fd             = "2*(x-3)"
+  #  fdd            = "2"
+  #  min = OpenCLMinimization::NewtonRampsonMinimizer.new(n, expected_point, f, fd, fdd)
+  #  min.minimize
+  #  min.x_minimum
+  #  min.f_minimum
+  #
+  class NewtonRampsonMinimizer
+    attr_reader :x_minimum
+    attr_reader :f_minimum
+
+    attr_writer :max_iterations
+    attr_writer :epsilon
+    attr_writer :golden
+
+    # == Parameters:
+    # * <tt>n</tt>: Number of Jobs
+    # * <tt>expected_point</tt>: Initial point
+    # * <tt>f</tt>: Original function
+    # * <tt>fd</tt>: First derivative function string
+    # * <tt>fdd</tt>: Second derivative function string
+    #
+    def initialize(n, expected_point, f, fd, fdd)
+      @n              = n
+      @expected_point = expected_point
+      @f              = f
+      @fd             = fd
+      @fdd            = fdd
+      @max_iterations = MAX_ITERATIONS_DEFAULT
+      @epsilon        = EPSILON_DEFAULT
+      @golden         = GOLDEN_DEFAULT
+      @sqrt_epsilon   = SQRT_EPSILON_DEFAULT
+    end
+
+    def minimize
+      # create Buffers for inputs and outputs
+      expected_buffer = FFI::Buffer.alloc_inout(:pointer, @n)
+      x_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+      f_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+
+      # set inputs
+      expected_buffer.write_array_of_float(@expected_point)
+
+      # call minimizer
+      OpenCLMinimization::opencl_minimize(@n, nil, expected_buffer, nil, 1, @f, @fd, @fdd, x_buffer, f_buffer, 0,
+                                          @max_iterations, @epsilon, @golden, @sqrt_epsilon, PATH_TO_KERNEL)
+
+      @x_minimum = Array.new(@n)
+      @f_minimum = Array.new(@n)
+      # read results
+      @x_minimum = x_buffer.read_array_of_float(@n)
+      @f_minimum = f_buffer.read_array_of_float(@n)
+    end
+  end
+
+  # = Bisection Minimizer.
+  # Basic minimization algorithm. Slow, but robust.
+  # See Unidimensional for methods.
+  # == Usage.
+  #  n              = 3
+  #  start_point    = [1, 3, 5]
+  #  expected_point = [1.5, 3.5, 5.5]
+  #  end_point      = [3, 5, 7]
+  #  f              = "pow((x-2)*(x-4)*(x-6), 2)+1"
+  #  min = OpenCLMinimization::BisectionMinimizer.new(n, start_point, expected_point, end_point, f)
+  #  min.minimize
+  #  min.x_minimum
+  #  min.f_minimum
+  #
+  class BisectionMinimizer < GodlSectionMinimizer
+
+    def minimize
+      # create Buffers for inputs and outputs
+      start_buffer    = FFI::Buffer.alloc_inout(:pointer, @n)
+      expected_buffer = FFI::Buffer.alloc_inout(:pointer, @n)
+      end_buffer      = FFI::Buffer.alloc_inout(:pointer, @n)
+      x_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+      f_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+
+      # set inputs
+      start_buffer.write_array_of_float(@start_point)
+      expected_buffer.write_array_of_float(@expected_point)
+      end_buffer.write_array_of_float(@end_point)
+
+      # call minimizer
+      OpenCLMinimization::opencl_minimize(@n, start_buffer, expected_buffer, end_buffer, 2, @f, "", "", x_buffer,
+                                          f_buffer, 0, @max_iterations, @epsilon, @golden, @sqrt_epsilon, PATH_TO_KERNEL)
+
+      @x_minimum = Array.new(@n)
+      @f_minimum = Array.new(@n)
+      # read results
+      @x_minimum = x_buffer.read_array_of_float(@n)
+      @f_minimum = f_buffer.read_array_of_float(@n)
+    end
+  end
+
+  # Direct port of Brent algorithm found on GSL.
+  # See Unidimensional for methods.
+  # == Usage
+  #  n              = 3
+  #  start_point    = [1, 3, 5]
+  #  expected_point = [1.5, 3.5, 5.5]
+  #  end_point      = [3, 5, 7]
+  #  f              = "pow((x-2)*(x-4)*(x-6), 2)+1"
+  #  min = OpenCLMinimization::BisectionMinimizer.new(n, start_point, expected_point, end_point, f)
+  #  min.minimize
+  #  min.x_minimum
+  #  min.f_minimum   
+  #  
+  class BrentMinimizer
+    attr_reader :x_minimum
+    attr_reader :f_minimum
+
+    attr_writer :max_iterations
+    attr_writer :epsilon
+    attr_writer :golden
+    attr_writer :sqrt_epsilon
+
+    # == Parameters:
+    # * <tt>n</tt>: Number of Jobs
+    # * <tt>start_point</tt>: Lower possible value
+    # * <tt>expected_point</tt>: Initial point
+    # * <tt>end_point</tt>: Higher possible value
+    # * <tt>f</tt>: Original function string
+    #
+    def initialize(n, start_point, expected_point, end_point, f)
+      @n              = n
+      @start_point    = start_point
+      @expected_point = expected_point
+      @end_point      = end_point
+      @f              = f
+      @max_iterations = MAX_ITERATIONS_DEFAULT
+      @epsilon        = EPSILON_DEFAULT
+      @golden         = GOLDEN_DEFAULT
+      @sqrt_epsilon   = SQRT_EPSILON_DEFAULT
+    end
+
+    def minimize
+      # create Buffers for inputs and outputs
+      start_buffer    = FFI::Buffer.alloc_inout(:pointer, @n)
+      expected_buffer = FFI::Buffer.alloc_inout(:pointer, @n)
+      end_buffer      = FFI::Buffer.alloc_inout(:pointer, @n)
+      x_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+      f_buffer        = FFI::Buffer.alloc_inout(:pointer, @n)
+
+      # set inputs
+      start_buffer.write_array_of_float(@start_point)
+      expected_buffer.write_array_of_float(@expected_point)
+      end_buffer.write_array_of_float(@end_point)
+
+      # call minimizer
+      OpenCLMinimization::opencl_minimize(@n, start_buffer, expected_buffer, end_buffer, 3, @f, "", "", x_buffer,
+                                          f_buffer, 0, @max_iterations, @epsilon, @golden, @sqrt_epsilon, PATH_TO_KERNEL)
+
+      @x_minimum = Array.new(@n)
+      @f_minimum = Array.new(@n)
+      # read results
+      @x_minimum = x_buffer.read_array_of_float(@n)
+      @f_minimum = f_buffer.read_array_of_float(@n)
+    end
+  end
+
+end

data/lib/opencl/unidimensional_kernel.cl

@@ -0,0 +1,47 @@
+// This is the kenel code for unidimensional integration methods.
+// This is loaded into memory at runtime and a functions will be appended at run time,
+// double f(double x)   - integrating function
+
+
+double rectangle(int i, double a, double dx);
+double trapezoid(int i, double a, double dx);
+double simpson(int i, double a, double dx);
+double romberg(int i, double a, double dx);
+
+__kernel void integrate(__global const double *a, __global const double *dx, __global const double *n,
+                        __global int *method, __global double *results) {
+ 
+    // Get the index of the current element to be processed
+    int i = get_global_id(0);
+ 
+    // Do the operation
+    if(i <= n) {
+        int m = *method;
+        switch(m) {
+            case 0: results[i] = rectangle(i, *a, *dx);
+                    break;
+            case 1: results[i] = trapezoid(i, *a, *dx);
+                    break;
+            case 2: results[i] = simpson(i, *a, *dx);
+                    break;
+            case 3: results[i] = romberg(i, *a, *dx);
+                    break;
+        }
+    }
+}
+
+double rectangle(int i, double a, double dx) {
+    double midpoint = a + (i + 0.5) * dx;
+    return dx * f(midpoint);
+}
+
+double trapezoid(int i, double a, double dx) {
+    double lower = a + i * dx;
+    return (0.5 * dx * (f(lower) + f(lower + dx)));
+}
+
+double simpson(int i, double a, double dx) {
+    double lower = a + i * dx;
+    return (dx / 6) * (f(lower) + 4 * f(lower + 0.5 * dx) + f(lower + dx));
+}
+