Added wrapper around mean function.

ShadyBoukhary · umar456 · commit 20b27f97d22b · 2019-07-23T18:17:04.000-04:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -29,6 +29,7 @@ ADD_JAR(${AF_JAR}
   com/arrayfire/Image.java
   com/arrayfire/Signal.java
   com/arrayfire/Util.java
+  com/arrayfire/Statistics.java
   com/util/JNIException.java
   com/arrayfire/ArrayFireException.java
   )
diff --git a/com/arrayfire/Statistics.java b/com/arrayfire/Statistics.java
@@ -0,0 +1,43 @@
+package com.arrayfire;
+
+public class Statistics extends ArrayFire {
+    static private native long afMean(long ref, int dim);
+
+    static private native long afMeanWeighted(long ref, long weightsRef, int dim);
+
+    static private native double afMeanAll(long ref, int[] dims);
+
+    static private native FloatComplex afMeanAllFloatComplex(long ref, int[] dims);
+    static private native DoubleComplex afMeanAllDoubleComplex(long ref, int[] dims);
+
+    //static private native jlong afMeanAllWeighted(long ref, long weightsRef);
+
+    static public Array mean(final Array in, int dim) {
+        return new Array(afMean(in.ref, dim));
+    }
+
+    static public Array mean(final Array in, final Array weights, int dim) {
+        return new Array(afMeanWeighted(in.ref, weights.ref, dim));
+    }
+
+    static public <T> T mean(final Array in, Class<T> type) throws Exception {
+        if (type == FloatComplex.class) {
+            FloatComplex res = (FloatComplex)afMeanAllFloatComplex(in.ref, in.dims());
+            return type.cast(res);
+        } else if (type == DoubleComplex.class) {
+            DoubleComplex res = (DoubleComplex)afMeanAllDoubleComplex(in.ref, in.dims());
+            return type.cast(res);
+        }
+
+        double res = afMeanAll(in.ref, in.dims());
+        if (type == Float.class) {
+            return type.cast(Float.valueOf((float)res));
+        } else if (type == Double.class) {
+            return type.cast(Double.valueOf((double) res));
+        } else if (type == Integer.class) {
+            return type.cast(Integer.valueOf((int) res));
+        }
+        throw new Exception("Unknown type");
+    }
+}
+
diff --git a/examples/HelloWorld.java b/examples/HelloWorld.java
@@ -25,6 +25,18 @@ public static void main(String[] args) {
         Arith.mul(d, b, c);
         d.print("d");
 
+
+        Array forMean = new Array();
+        Array weights = new Array();
+        Data.randn(forMean, new int[] {1}, Array.FloatComplexType);
+        Data.randn(weights, new int[] {1}, Array.FloatComplexType);
+        forMean.print("forMean");
+        //Array mean = Statistics.mean(forMean, weights, 0);
+        //mean.print("mean");
+
+        DoubleComplex abc = Statistics.mean(forMean, DoubleComplex.class);
+        System.out.println(String.format("Mean is: %f and %f", abc.real(), abc.imag()));
+
         System.out.println("Create a 2-by-3 matrix from host data");
         int[] dims = new int[] { 2, 3 };
         int total = 1;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -20,6 +20,7 @@ ADD_LIBRARY(${AF_LIB} SHARED
   data.cpp
   image.cpp
   signal.cpp
+  statistics.cpp
   util.cpp
   )
 
diff --git a/src/statistics.cpp b/src/statistics.cpp
@@ -0,0 +1,54 @@
+
+#include "jni_helper.h"
+
+BEGIN_EXTERN_C
+
+#define STATISTICS_FUNC(FUNC) AF_MANGLE(Statistics, FUNC)
+
+JNIEXPORT jlong JNICALL STATISTICS_FUNC(afMean)(JNIEnv *env, jclass clazz,
+                                               jlong ref, jint dim) {
+  af_array ret = 0;
+  AF_CHECK(af_mean(&ret, ARRAY(ref), dim));
+  return JLONG(ret);
+}
+
+JNIEXPORT jlong JNICALL STATISTICS_FUNC(afMeanWeighted)(JNIEnv *env, jclass clazz,
+                                                        jlong ref, jlong weightsRef,
+                                                        jint dim) {
+  af_array ret = 0;
+  AF_CHECK(af_mean_weighted(&ret, ARRAY(ref), ARRAY(weightsRef), dim));
+  return JLONG(ret);
+}
+
+JNIEXPORT jdouble JNICALL STATISTICS_FUNC(afMeanAll)(JNIEnv *env,
+                                                    jclass clazz, jlong ref,
+                                                    jintArray dims) {
+  double ret = 0;
+  jint *dimptr = env->GetIntArrayElements(dims, 0);
+  dim_t tdims[4] = {dimptr[0], dimptr[1], dimptr[2], dimptr[3]};
+  AF_CHECK(af_mean_all(&ret, NULL, ARRAY(ref)));
+  env->ReleaseIntArrayElements(dims, dimptr, 0);
+  return  (jdouble)ret;
+}
+
+#define INSTANTIATE_MEAN(jtype, param)                                  \
+    JNIEXPORT jobject JNICALL STATISTICS_FUNC(afMeanAll##jtype)(JNIEnv *env, jclass clazz, \
+                                                               jlong ref, \
+                                                               jintArray dims) { \
+    double real = 0, img = 0;                                           \
+    jint *dimptr = env->GetIntArrayElements(dims, 0);                   \
+    dim_t tdims[4] = {dimptr[0], dimptr[1], dimptr[2], dimptr[3]};      \
+    AF_CHECK(af_mean_all(&real, &img, ARRAY(ref)));                     \
+    env->ReleaseIntArrayElements(dims, dimptr, 0);                      \
+    jclass cls = env->FindClass("com/arrayfire/"#jtype);                \
+    jmethodID id = env->GetMethodID(cls, "<init>", "("#param")V");      \
+    jobject obj = env->NewObject(cls, id, real, img);                   \
+    return obj;                                                         \
+}
+
+INSTANTIATE_MEAN(FloatComplex, FF)
+INSTANTIATE_MEAN(DoubleComplex, DD)
+
+END_EXTERN_C
+
+

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@ ADD_JAR(${AF_JAR}`
`29`	`29`	`com/arrayfire/Image.java`
`30`	`30`	`com/arrayfire/Signal.java`
`31`	`31`	`com/arrayfire/Util.java`
	`32`	`+ com/arrayfire/Statistics.java`
`32`	`33`	`com/util/JNIException.java`
`33`	`34`	`com/arrayfire/ArrayFireException.java`
`34`	`35`	`)`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ ADD_LIBRARY(${AF_LIB} SHARED`
`20`	`20`	`data.cpp`
`21`	`21`	`image.cpp`
`22`	`22`	`signal.cpp`
	`23`	`+ statistics.cpp`
`23`	`24`	`util.cpp`
`24`	`25`	`)`
`25`	`26`