Adding functions from algorithm.h

arrayfire · pavanky · Nov 3, 2016 · Feb 8, 2017 · Feb 23, 2017 · Feb 23, 2017
commit bde6e26144d6923e38da18fa5c01eed725a5ce06
diff --git a/arrayfire.lua b/arrayfire.lua
@@ -4,6 +4,7 @@ require('arrayfire.dim4')
 require('arrayfire.util')
 require('arrayfire.array')
 require('arrayfire.arith')
+require('arrayfire.algorithm')
 require('arrayfire.device')
 
 return af
diff --git a/arrayfire/algorithm.lua b/arrayfire/algorithm.lua
@@ -0,0 +1,200 @@
+require('arrayfire.lib')
+require('arrayfire.defines')
+require('arrayfire.array')
+local ffi  = require( "ffi" )
+
+local funcs = {}
+
+funcs[30] = [[
+    af_err af_sum(af_array *out, const af_array in, const int dim);
+    af_err af_product(af_array *out, const af_array in, const int dim);
+    af_err af_min(af_array *out, const af_array in, const int dim);
+    af_err af_max(af_array *out, const af_array in, const int dim);
+    af_err af_all_true(af_array *out, const af_array in, const int dim);
+    af_err af_any_true(af_array *out, const af_array in, const int dim);
+    af_err af_count(af_array *out, const af_array in, const int dim);
+    af_err af_sum_all(double *real, double *imag, const af_array in);
+    af_err af_product_all(double *real, double *imag, const af_array in);
+    af_err af_min_all(double *real, double *imag, const af_array in);
+    af_err af_max_all(double *real, double *imag, const af_array in);
+    af_err af_all_true_all(double *real, double *imag, const af_array in);
+    af_err af_any_true_all(double *real, double *imag, const af_array in);
+    af_err af_count_all(double *real, double *imag, const af_array in);
+    af_err af_imin(af_array *out, af_array *idx, const af_array in, const int dim);
+    af_err af_imax(af_array *out, af_array *idx, const af_array in, const int dim);
+    af_err af_imin_all(double *real, double *imag, unsigned *idx, const af_array in);
+    af_err af_imax_all(double *real, double *imag, unsigned *idx, const af_array in);
+    af_err af_accum(af_array *out, const af_array in, const int dim);
+    af_err af_where(af_array *idx, const af_array in);
+    af_err af_diff1(af_array *out, const af_array in, const int dim);
+    af_err af_diff2(af_array *out, const af_array in, const int dim);
+    af_err af_sort(af_array *out, const af_array in, const unsigned dim, const bool isAscending);
+    af_err af_sort_index(af_array *out, af_array *indices, const af_array in,
+                               const unsigned dim, const bool isAscending);
+    af_err af_sort_by_key(af_array *out_keys, af_array *out_values,
+                                const af_array keys, const af_array values,
+                                const unsigned dim, const bool isAscending);
+    af_err af_set_unique(af_array *out, const af_array in, const bool is_sorted);
+    af_err af_set_union(af_array *out, const af_array first, const af_array second, const bool is_unique);
+    af_err af_set_intersect(af_array *out, const af_array first, const af_array second, const bool is_unique);
+]]
+
+funcs[31] = [[
+    af_err af_sum_nan(af_array *out, const af_array in, const int dim, const double nanval);
+    af_err af_product_nan(af_array *out, const af_array in, const int dim, const double nanval);
+    af_err af_sum_nan_all(double *real, double *imag, const af_array in, const double nanval);
+    af_err af_product_nan_all(double *real, double *imag, const af_array in, const double nanval);
+]]
+
+funcs[34] = [[
+    af_err af_scan(af_array *out, const af_array in, const int dim, af_binary_op op, bool inclusive_scan);
+    af_err af_scan_by_key(af_array *out, const af_array key, const af_array in, const int dim, af_binary_op op, bool inclusive_scan);
+]]
+
+af.lib.cdef(funcs)
+
+local c_array_p = af.ffi.c_array_p
+local init = af.Array.init
+local c_ptr_t = af.ffi.c_ptr_t
+
+local reduceFuncsWithNan = {'sum', 'product'}
+for _, func in pairs(reduceFuncsWithNan) do
+   af[func] = function(input, dim, nanval)
+      if dim then
+         local res = c_array_p()
+         if nanval then
+            af.clib['af_' .. func .. '_nan'](res, input:get(), dim, nanval)
+         else
+            af.clib['af_' .. func .. ''](res, input:get(), dim)
+         end
+         return init(res[0])
+      else
+         local res = c_ptr_t('double', 2)
+         if nanval then
+            af.clib['af_' .. func .. '_nan_all'](res + 0, res + 1, input:get(), nanval)
+         else
+            af.clib['af_' .. func .. '_all'](res + 0, res + 1, input:get())
+         end
+         return (res[1] == 0) and res[0] or {real = res[0], imag = res[1]}
+      end
+   end
+end
+
+local reduceFuncs = {
+   min = 'min',
+   max = 'max',
+   anyTrue = 'any_true',
+   allTrue = 'all_true',
+   count = count,
+}
+
+for func,cfunc in pairs(reduceFuncs) do
+   af[func] = function(input, dim)
+      if dim then
+         local res = c_array_p()
+         af.clib['af_' .. cfunc .. ''](res, input:get(), dim)
+         return init(res[0])
+      else
+         local res = c_ptr_t('double', 2)
+         af.clib['af_' .. cfunc .. '_all'](res + 0, res + 1, input:get())
+         return (res[1] == 0) and res[0] or {real = res[0], imag = res[1]}
+      end
+   end
+end
+
+local ireduceFuncs = {'imin', 'imax'}
+
+for _,func in pairs(reduceFuncs) do
+   af[func] = function(input, dim)
+      if dim then
+         local val = c_array_p()
+         local idx = c_array_p()
+         af.clib['af_' .. func .. ''](val, idx, input:get(), dim)
+         return init(val[0]), init(idx[0])
+      else
+         local val = c_ptr_t('double', 2)
+         local idx = c_ptr_t('unsigned int')
+         af.clib['af_' .. func .. '_all'](val + 0, val + 1, idx + 0, input:get())
+         if (val[1] == 0) then
+            return val[0], idx[0]
+         else
+            return {real = val[0], imag = val[1]}, idx[0]
+         end
+      end
+   end
+end
+
+local dimAlgos = {
+   'accum',
+   'diff1',
+   'diff2',
+}
+
+for _, func in ipairs(dimAlgos) do
+   af[func] = function(input, dim)
+      local res = c_array_p()
+      af.clib['af_' .. func](res, input:get(), dim or 0)
+      return init(res[0])
+   end
+end
+
+af.where = function(input)
+   local res = c_array_p()
+   af.clib.af_where(res, input:get());
+   return init(res[0])
+end
+
+af.sort = function(input, dim, isAscending)
+   local res = c_array_p()
+   af.clib.af_sort(res, input:get(), dim or 0, isAscending == nil and true or isAscending)
+   return init(res[0])
+end
+
+af.sortIndex = function(input, dim, isAscending)
+   local val = c_array_p()
+   local idx = c_array_p()
+   af.clib.af_sort_index(val, idx, input:get(), dim or 0, isAscending == nil and true or isAscending)
+   return init(val[0]), init(res[0])
+end
+
+af.sortByKey = function(inputKeys, inputVals, dim, isAscending)
+   local outVals = c_array_p()
+   local outKeys = c_array_p()
+   af.clib.af_sort_by_key(outKeys, outVals,
+                          inputKeys:get(), inputVals:get(),
+                          dim or 0, isAscending == nil and true or isAscending)
+   return init(outKeys[0]), init(outVals[0])
+end
+
+af.setUnique = function(input, isSorted)
+   local res = c_array_p()
+   af.clib.af_set_unique(res, input:get(), isSorted == nil and false or isSorted)
+   return init(res[0])
+end
+
+local setOps = {
+   setUnion = 'set_union',
+   setIntersect = 'set_intersect',
+}
+
+for func, cfunc in pairs(setOps) do
+   af[func] = function(first, second, isUnique)
+      local res = c_array_p()
+      af.clib['af_' .. cfunc](res, first:get(), second:get(), isUnique == nil and false or isUnique)
+      return init(res[0])
+   end
+end
+
+af.scan = function(input, dim, op, isInclusive)
+   local res = c_array_p()
+   af.clib.af_scan(res, input:get(), dim or 0,
+                   op or af.binary_op.add, isInclusive == nil and true or isInclusive)
+   return init(res[0])
+end
+
+af.scanByKey = function(inputKey, inputVal, dim, op, isInclusive)
+   local res = c_array_p()
+   af.clib.af_scan_by_key(res, inputKey:get(), inputVal:get(), dim or 0,
+                          op or af.binary_op.add, isInclusive == nil and true or isInclusive)
+   return init(res[0])
+end
diff --git a/arrayfire/array.lua b/arrayfire/array.lua
@@ -84,6 +84,7 @@ end
 local init = function(ptr)
    local self = setmetatable({}, Array)
    self._ptr = ffi.gc(ptr, release_array)
+   self.isArray = true
    return self
 end
 

diff --git a/arrayfire/lib.lua b/arrayfire/lib.lua
@@ -27,9 +27,28 @@ end
 
 ffi.cdef[[
 typedef void * af_array;
-typedef int af_dtype;
 typedef int af_err;
+typedef int af_dtype;
 typedef int af_source;
+typedef int af_interp_type;
+typedef int af_border_type;
+typedef int af_connectivity;
+typedef int af_match_type;
+typedef int af_cspace_t;
+typedef int af_mat_prop;
+typedef int af_conv_mode;
+typedef int af_conv_domain;
+typedef int af_mat_prop;
+typedef int af_colormap;
+typedef int af_norm_type;
+typedef int af_ycc_std;
+typedef int af_image_format;
+typedef int af_backend;
+typedef int af_marker_type;
+typedef int af_moment_type;
+typedef int af_storage;
+typedef int af_binary_op;
+typedef int af_random_engine_type;
 
 typedef struct af_cfloat {
     float real;

diff --git a/arrayfire/util.lua b/arrayfire/util.lua
@@ -29,5 +29,9 @@ funcs[34] = [[
 af.lib.cdef(funcs)
 
 af.print = function(arr)
-   af.clib.af_print_array_gen(ffi.cast("char *", "ArrayFire Array"), arr:get(), 4)
+   if type(arr) == 'table' and arr.isArray then
+      af.clib.af_print_array_gen(ffi.cast("char *", "ArrayFire Array"), arr:get(), 4)
+   else
+      print(arr)
+   end
 end
diff --git a/rocks/arrayfire-scm-1.rockspec b/rocks/arrayfire-scm-1.rockspec
@@ -17,12 +17,13 @@ build = {
    type = "builtin",
    modules = {
       arrayfire = "arrayfire.lua",
-      ["arrayfire.lib"]     = "arrayfire/lib.lua",
-      ["arrayfire.util"]    = "arrayfire/util.lua",
-      ["arrayfire.array"]   = "arrayfire/array.lua",
-      ["arrayfire.defines"] = "arrayfire/defines.lua",
-      ["arrayfire.device"]  = "arrayfire/device.lua",
-      ["arrayfire.dim4"]    = "arrayfire/dim4.lua",
-      ["arrayfire.arith"]    = "arrayfire/arith.lua",
+      ["arrayfire.lib"]       = "arrayfire/lib.lua",
+      ["arrayfire.util"]      = "arrayfire/util.lua",
+      ["arrayfire.array"]     = "arrayfire/array.lua",
+      ["arrayfire.defines"]   = "arrayfire/defines.lua",
+      ["arrayfire.device"]    = "arrayfire/device.lua",
+      ["arrayfire.dim4"]      = "arrayfire/dim4.lua",
+      ["arrayfire.arith"]     = "arrayfire/arith.lua",
+      ["arrayfire.algorithm"] = "arrayfire/algorithm.lua",
    },
 }