Skip to content

Commit 2dfae7c

Browse files
kowalewskijpradeep
kowalewskij
authored and
pradeep
committed
Added algorithm.h API
1 parent 8ea1eb4 commit 2dfae7c

File tree

1 file changed

+273
-14
lines changed

1 file changed

+273
-14
lines changed

‎src/Wrapper/Algorithm.cs‎

Lines changed: 273 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,78 @@ namespace ArrayFire
3939
{
4040
public static class Algorithm
4141
{
42+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
43+
public static Array Sum(Array arr, int dim = -1)
44+
{
45+
IntPtr ptr;
46+
Internal.VERIFY(AFAlgorithm.af_sum(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
47+
return new Array(ptr);
48+
}
49+
50+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
51+
public static Array Sum(Array arr, int dim, double nanval)
52+
{
53+
IntPtr ptr;
54+
Internal.VERIFY(AFAlgorithm.af_sum_nan(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions), nanval));
55+
return new Array(ptr);
56+
}
57+
58+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
59+
public static Array Product(Array arr, int dim = -1)
60+
{
61+
IntPtr ptr;
62+
Internal.VERIFY(AFAlgorithm.af_product(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
63+
return new Array(ptr);
64+
}
65+
66+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
67+
public static Array Product(Array arr, int dim, double nanval)
68+
{
69+
IntPtr ptr;
70+
Internal.VERIFY(AFAlgorithm.af_product_nan(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions), nanval));
71+
return new Array(ptr);
72+
}
73+
74+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
75+
public static Array Min(Array arr, int dim = -1)
76+
{
77+
IntPtr ptr;
78+
Internal.VERIFY(AFAlgorithm.af_min(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
79+
return new Array(ptr);
80+
}
81+
82+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
83+
public static Array Max(Array arr, int dim = -1)
84+
{
85+
IntPtr ptr;
86+
Internal.VERIFY(AFAlgorithm.af_max(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
87+
return new Array(ptr);
88+
}
89+
90+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
91+
public static Array AllTrue(Array arr, int dim = -1)
92+
{
93+
IntPtr ptr;
94+
Internal.VERIFY(AFAlgorithm.af_all_true(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
95+
return new Array(ptr);
96+
}
97+
98+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
99+
public static Array AnyTrue(Array arr, int dim = -1)
100+
{
101+
IntPtr ptr;
102+
Internal.VERIFY(AFAlgorithm.af_any_true(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
103+
return new Array(ptr);
104+
}
105+
106+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
107+
public static Array Count(Array arr, int dim = -1)
108+
{
109+
IntPtr ptr;
110+
Internal.VERIFY(AFAlgorithm.af_count(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
111+
return new Array(ptr);
112+
}
113+
42114
[MethodImpl(MethodImplOptions.AggressiveInlining)]
43115
public static Complex SumAll(Array arr)
44116
{
@@ -48,30 +120,217 @@ public static Complex SumAll(Array arr)
48120
}
49121

50122
[MethodImpl(MethodImplOptions.AggressiveInlining)]
51-
public static object MinAll<T>(Array arr)
123+
public static Complex SumAll(Array arr, double nanval)
124+
{
125+
double r, i;
126+
Internal.VERIFY(AFAlgorithm.af_sum_nan_all(out r, out i, arr._ptr, nanval));
127+
return new Complex(r, i);
128+
}
129+
130+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
131+
public static Complex ProductAll(Array arr)
132+
{
133+
double r, i;
134+
Internal.VERIFY(AFAlgorithm.af_product_all(out r, out i, arr._ptr));
135+
return new Complex(r, i);
136+
}
137+
138+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
139+
public static Complex ProductAll(Array arr, double nanval)
140+
{
141+
double r, i;
142+
Internal.VERIFY(AFAlgorithm.af_product_nan_all(out r, out i, arr._ptr, nanval));
143+
return new Complex(r, i);
144+
}
145+
146+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
147+
public static Complex MinAll(Array arr)
52148
{
53-
af_dtype dtype = Internal.toDType<T>();
54149
double r, i;
55150
Internal.VERIFY(AFAlgorithm.af_min_all(out r, out i, arr._ptr));
56-
if (dtype == af_dtype.c32 || dtype == af_dtype.c64) {
57-
return new Complex(r, i);
58-
} else {
59-
return Convert.ChangeType(r, Internal.toClrType(dtype));
60-
}
151+
return new Complex(r, i);
61152
}
62153

63154
[MethodImpl(MethodImplOptions.AggressiveInlining)]
64-
public static object MaxAll<T>(Array arr)
155+
public static Complex MaxAll(Array arr)
65156
{
66-
af_dtype dtype = Internal.toDType<T>();
67157
double r, i;
68158
Internal.VERIFY(AFAlgorithm.af_max_all(out r, out i, arr._ptr));
69-
if (dtype == af_dtype.c32 || dtype == af_dtype.c64) {
70-
return new Complex(r, i);
71-
} else {
72-
return Convert.ChangeType(r, Internal.toClrType(dtype));
159+
return new Complex(r, i);
160+
}
161+
162+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
163+
public static Complex AllTrueAll(Array arr)
164+
{
165+
double r, i;
166+
Internal.VERIFY(AFAlgorithm.af_all_true_all(out r, out i, arr._ptr));
167+
return new Complex(r, i);
168+
}
169+
170+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
171+
public static Complex AnyTrueAll(Array arr)
172+
{
173+
double r, i;
174+
Internal.VERIFY(AFAlgorithm.af_any_true_all(out r, out i, arr._ptr));
175+
return new Complex(r, i);
176+
}
177+
178+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
179+
public static Complex CountAll(Array arr)
180+
{
181+
double r, i;
182+
Internal.VERIFY(AFAlgorithm.af_count_all(out r, out i, arr._ptr));
183+
return new Complex(r, i);
184+
}
185+
186+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
187+
public static Array Min(Array arr, out Array idx ,int dim = -1)
188+
{
189+
IntPtr outPtr;
190+
IntPtr idxPtr;
191+
Internal.VERIFY(AFAlgorithm.af_imin(out outPtr, out idxPtr, arr._ptr, getFNSD(dim, arr.Dimensions)));
192+
idx = new Array(idxPtr);
193+
return new Array(outPtr);
194+
}
195+
196+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
197+
public static Array Max(Array arr, out Array idx, int dim = -1)
198+
{
199+
IntPtr outPtr;
200+
IntPtr idxPtr;
201+
Internal.VERIFY(AFAlgorithm.af_imax(out outPtr, out idxPtr, arr._ptr, getFNSD(dim, arr.Dimensions)));
202+
idx = new Array(idxPtr);
203+
return new Array(outPtr);
204+
}
205+
206+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
207+
public static Complex MinAll(Array arr, out uint idx)
208+
{
209+
double r, i;
210+
Internal.VERIFY(AFAlgorithm.af_imin_all(out r, out i, out idx ,arr._ptr));
211+
return new Complex(r, i);
212+
}
213+
214+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
215+
public static Complex MaxAll(Array arr, out uint idx)
216+
{
217+
double r, i;
218+
Internal.VERIFY(AFAlgorithm.af_imax_all(out r, out i, out idx, arr._ptr));
219+
return new Complex(r, i);
220+
}
221+
222+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
223+
public static Array Accumulate(Array arr, int dim = -1)
224+
{
225+
IntPtr ptr;
226+
Internal.VERIFY(AFAlgorithm.af_accum(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions)));
227+
return new Array(ptr);
228+
}
229+
230+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
231+
public static Array Scan(Array arr, int dim, af_binary_op op, bool inclusive_scan = true)
232+
{
233+
IntPtr ptr;
234+
Internal.VERIFY(AFAlgorithm.af_scan(out ptr, arr._ptr, getFNSD(dim, arr.Dimensions), op, inclusive_scan));
235+
return new Array(ptr);
236+
}
237+
238+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
239+
public static Array ScanByKey(Array key, Array arr, int dim, af_binary_op op, bool inclusive_scan = true)
240+
{
241+
IntPtr ptr;
242+
Internal.VERIFY(AFAlgorithm.af_scan_by_key(out ptr, key._ptr, arr._ptr, getFNSD(dim, arr.Dimensions), op, inclusive_scan));
243+
return new Array(ptr);
244+
}
245+
246+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
247+
public static Array Where(Array arr)
248+
{
249+
IntPtr ptr;
250+
Internal.VERIFY(AFAlgorithm.af_where(out ptr, arr._ptr));
251+
return new Array(ptr);
252+
}
253+
254+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
255+
public static Array Diff1(Array arr, int dim = 0)
256+
{
257+
IntPtr ptr;
258+
Internal.VERIFY(AFAlgorithm.af_diff1(out ptr, arr._ptr, dim));
259+
return new Array(ptr);
260+
}
261+
262+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
263+
public static Array Diff2(Array arr, int dim = 0)
264+
{
265+
IntPtr ptr;
266+
Internal.VERIFY(AFAlgorithm.af_diff2(out ptr, arr._ptr, dim));
267+
return new Array(ptr);
268+
}
269+
270+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
271+
public static Array Sort(Array arr, uint dim = 0, bool isAscending = true)
272+
{
273+
IntPtr ptr;
274+
Internal.VERIFY(AFAlgorithm.af_sort(out ptr, arr._ptr, dim, isAscending));
275+
return new Array(ptr);
276+
}
277+
278+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
279+
public static Array Sort(Array arr, out Array indices, uint dim = 0, bool isAscending = true)
280+
{
281+
IntPtr outPtr, indPtr;
282+
Internal.VERIFY(AFAlgorithm.af_sort_index(out outPtr, out indPtr , arr._ptr, dim, isAscending));
283+
indices = new Array(indPtr);
284+
return new Array(outPtr);
285+
}
286+
287+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
288+
public static Array Sort(out Array outValues, Array keys, Array values, uint dim = 0, bool isAscending = true)
289+
{
290+
IntPtr outKeyPtr;
291+
IntPtr outValPtr;
292+
Internal.VERIFY(AFAlgorithm.af_sort_by_key(out outKeyPtr, out outValPtr, keys._ptr, values._ptr, dim, isAscending));
293+
outValues = new Array(outValPtr);
294+
return new Array(outKeyPtr);
295+
}
296+
297+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
298+
public static Array SetUnique(Array arr, bool isSorted = false)
299+
{
300+
IntPtr ptr;
301+
Internal.VERIFY(AFAlgorithm.af_set_unique(out ptr, arr._ptr, isSorted));
302+
return new Array(ptr);
303+
}
304+
305+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
306+
public static Array SetUnion(Array arr1, Array arr2, bool isUnique = false)
307+
{
308+
IntPtr ptr;
309+
Internal.VERIFY(AFAlgorithm.af_set_union(out ptr, arr1._ptr, arr2._ptr, isUnique));
310+
return new Array(ptr);
311+
}
312+
313+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
314+
public static Array SetIntersect(Array arr1, Array arr2, bool isUnique = false)
315+
{
316+
IntPtr ptr;
317+
Internal.VERIFY(AFAlgorithm.af_set_intersect(out ptr, arr1._ptr, arr2._ptr, isUnique));
318+
return new Array(ptr);
319+
}
320+
321+
/// Get the first non-zero dimension
322+
private static int getFNSD(int dim, int[] dims)
323+
{
324+
if (dim >= 0) return dim;
325+
326+
for (int i = 0; i < 4; ++i)
327+
{
328+
if (dims[i] > 1)
329+
{
330+
return i;
331+
}
73332
}
333+
return 0;
74334
}
75-
// TODO: Add the other algorithms
76335
}
77336
}

0 commit comments

Comments
 (0)