Skip to content

Commit aa87e9b

Browse files
royalstream9prady9
royalstream
authored and
9prady9
committed
Array<T> -> Array
1 parent 763eb2b commit aa87e9b

File tree

8 files changed

+332
-316
lines changed

8 files changed

+332
-316
lines changed

‎Wrapper/Arith.cs

Lines changed: 39 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -37,12 +37,12 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3737

3838
namespace ArrayFire
3939
{
40+
// we can't make Arith static because Array inherits from it (so the F# Core.Operators free functions work correctly)
4041
public /*static*/ class Arith
4142
{
42-
// we can't make Arith static because Array<T> inherits from it (so the F# Core.Operators free functions work correctly)
4343
protected Arith() { }
4444

45-
#region Mathematical Functions
45+
#region Mathematical Functions
4646
#if _
4747
for (\w+) in
4848
Sin Sinh Asin Asinh
@@ -55,120 +55,120 @@ Abs Sigmoid Factorial
5555
Round Trunc Floor Ceil
5656
do
5757
[MethodImpl(MethodImplOptions.AggressiveInlining)]
58-
public static Array<T> $1<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_$L1(out ptr, arr._ptr)); return new Array<T>(ptr); }
58+
public static Array $1(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_$L1(out ptr, arr._ptr)); return new Array(ptr); }
5959
#else
6060
[MethodImpl(MethodImplOptions.AggressiveInlining)]
61-
public static Array<T> Sin<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sin(out ptr, arr._ptr)); return new Array<T>(ptr); }
61+
public static Array Sin(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sin(out ptr, arr._ptr)); return new Array(ptr); }
6262

6363
[MethodImpl(MethodImplOptions.AggressiveInlining)]
64-
public static Array<T> Sinh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sinh(out ptr, arr._ptr)); return new Array<T>(ptr); }
64+
public static Array Sinh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sinh(out ptr, arr._ptr)); return new Array(ptr); }
6565

6666
[MethodImpl(MethodImplOptions.AggressiveInlining)]
67-
public static Array<T> Asin<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_asin(out ptr, arr._ptr)); return new Array<T>(ptr); }
67+
public static Array Asin(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_asin(out ptr, arr._ptr)); return new Array(ptr); }
6868

6969
[MethodImpl(MethodImplOptions.AggressiveInlining)]
70-
public static Array<T> Asinh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_asinh(out ptr, arr._ptr)); return new Array<T>(ptr); }
70+
public static Array Asinh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_asinh(out ptr, arr._ptr)); return new Array(ptr); }
7171

7272
[MethodImpl(MethodImplOptions.AggressiveInlining)]
73-
public static Array<T> Cos<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cos(out ptr, arr._ptr)); return new Array<T>(ptr); }
73+
public static Array Cos(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cos(out ptr, arr._ptr)); return new Array(ptr); }
7474

7575
[MethodImpl(MethodImplOptions.AggressiveInlining)]
76-
public static Array<T> Cosh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cosh(out ptr, arr._ptr)); return new Array<T>(ptr); }
76+
public static Array Cosh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cosh(out ptr, arr._ptr)); return new Array(ptr); }
7777

7878
[MethodImpl(MethodImplOptions.AggressiveInlining)]
79-
public static Array<T> Acos<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_acos(out ptr, arr._ptr)); return new Array<T>(ptr); }
79+
public static Array Acos(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_acos(out ptr, arr._ptr)); return new Array(ptr); }
8080

8181
[MethodImpl(MethodImplOptions.AggressiveInlining)]
82-
public static Array<T> Acosh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_acosh(out ptr, arr._ptr)); return new Array<T>(ptr); }
82+
public static Array Acosh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_acosh(out ptr, arr._ptr)); return new Array(ptr); }
8383

8484
[MethodImpl(MethodImplOptions.AggressiveInlining)]
85-
public static Array<T> Tan<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tan(out ptr, arr._ptr)); return new Array<T>(ptr); }
85+
public static Array Tan(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tan(out ptr, arr._ptr)); return new Array(ptr); }
8686

8787
[MethodImpl(MethodImplOptions.AggressiveInlining)]
88-
public static Array<T> Tanh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tanh(out ptr, arr._ptr)); return new Array<T>(ptr); }
88+
public static Array Tanh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tanh(out ptr, arr._ptr)); return new Array(ptr); }
8989

9090
[MethodImpl(MethodImplOptions.AggressiveInlining)]
91-
public static Array<T> Atan<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_atan(out ptr, arr._ptr)); return new Array<T>(ptr); }
91+
public static Array Atan(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_atan(out ptr, arr._ptr)); return new Array(ptr); }
9292

9393
[MethodImpl(MethodImplOptions.AggressiveInlining)]
94-
public static Array<T> Atanh<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_atanh(out ptr, arr._ptr)); return new Array<T>(ptr); }
94+
public static Array Atanh(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_atanh(out ptr, arr._ptr)); return new Array(ptr); }
9595

9696
[MethodImpl(MethodImplOptions.AggressiveInlining)]
97-
public static Array<T> Exp<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_exp(out ptr, arr._ptr)); return new Array<T>(ptr); }
97+
public static Array Exp(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_exp(out ptr, arr._ptr)); return new Array(ptr); }
9898

9999
[MethodImpl(MethodImplOptions.AggressiveInlining)]
100-
public static Array<T> Expm1<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_expm1(out ptr, arr._ptr)); return new Array<T>(ptr); }
100+
public static Array Expm1(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_expm1(out ptr, arr._ptr)); return new Array(ptr); }
101101

102102
[MethodImpl(MethodImplOptions.AggressiveInlining)]
103-
public static Array<T> Log<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log(out ptr, arr._ptr)); return new Array<T>(ptr); }
103+
public static Array Log(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log(out ptr, arr._ptr)); return new Array(ptr); }
104104

105105
[MethodImpl(MethodImplOptions.AggressiveInlining)]
106-
public static Array<T> Log10<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log10(out ptr, arr._ptr)); return new Array<T>(ptr); }
106+
public static Array Log10(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log10(out ptr, arr._ptr)); return new Array(ptr); }
107107

108108
[MethodImpl(MethodImplOptions.AggressiveInlining)]
109-
public static Array<T> Log1p<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log1p(out ptr, arr._ptr)); return new Array<T>(ptr); }
109+
public static Array Log1p(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log1p(out ptr, arr._ptr)); return new Array(ptr); }
110110

111111
[MethodImpl(MethodImplOptions.AggressiveInlining)]
112-
public static Array<T> Log2<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log2(out ptr, arr._ptr)); return new Array<T>(ptr); }
112+
public static Array Log2(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_log2(out ptr, arr._ptr)); return new Array(ptr); }
113113

114114
[MethodImpl(MethodImplOptions.AggressiveInlining)]
115-
public static Array<T> Erf<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_erf(out ptr, arr._ptr)); return new Array<T>(ptr); }
115+
public static Array Erf(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_erf(out ptr, arr._ptr)); return new Array(ptr); }
116116

117117
[MethodImpl(MethodImplOptions.AggressiveInlining)]
118-
public static Array<T> Erfc<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_erfc(out ptr, arr._ptr)); return new Array<T>(ptr); }
118+
public static Array Erfc(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_erfc(out ptr, arr._ptr)); return new Array(ptr); }
119119

120120
[MethodImpl(MethodImplOptions.AggressiveInlining)]
121-
public static Array<T> Sqrt<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sqrt(out ptr, arr._ptr)); return new Array<T>(ptr); }
121+
public static Array Sqrt(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sqrt(out ptr, arr._ptr)); return new Array(ptr); }
122122

123123
[MethodImpl(MethodImplOptions.AggressiveInlining)]
124-
public static Array<T> Pow2<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_pow2(out ptr, arr._ptr)); return new Array<T>(ptr); }
124+
public static Array Pow2(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_pow2(out ptr, arr._ptr)); return new Array(ptr); }
125125

126126
[MethodImpl(MethodImplOptions.AggressiveInlining)]
127-
public static Array<T> Cbrt<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cbrt(out ptr, arr._ptr)); return new Array<T>(ptr); }
127+
public static Array Cbrt(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_cbrt(out ptr, arr._ptr)); return new Array(ptr); }
128128

129129
[MethodImpl(MethodImplOptions.AggressiveInlining)]
130-
public static Array<T> LGamma<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_lgamma(out ptr, arr._ptr)); return new Array<T>(ptr); }
130+
public static Array LGamma(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_lgamma(out ptr, arr._ptr)); return new Array(ptr); }
131131

132132
[MethodImpl(MethodImplOptions.AggressiveInlining)]
133-
public static Array<T> TGamma<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tgamma(out ptr, arr._ptr)); return new Array<T>(ptr); }
133+
public static Array TGamma(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_tgamma(out ptr, arr._ptr)); return new Array(ptr); }
134134

135135
[MethodImpl(MethodImplOptions.AggressiveInlining)]
136-
public static Array<T> Abs<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_abs(out ptr, arr._ptr)); return new Array<T>(ptr); }
136+
public static Array Abs(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_abs(out ptr, arr._ptr)); return new Array(ptr); }
137137

138138
[MethodImpl(MethodImplOptions.AggressiveInlining)]
139-
public static Array<T> Sigmoid<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sigmoid(out ptr, arr._ptr)); return new Array<T>(ptr); }
139+
public static Array Sigmoid(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_sigmoid(out ptr, arr._ptr)); return new Array(ptr); }
140140

141141
[MethodImpl(MethodImplOptions.AggressiveInlining)]
142-
public static Array<T> Factorial<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_factorial(out ptr, arr._ptr)); return new Array<T>(ptr); }
142+
public static Array Factorial(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_factorial(out ptr, arr._ptr)); return new Array(ptr); }
143143

144144
[MethodImpl(MethodImplOptions.AggressiveInlining)]
145-
public static Array<T> Round<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_round(out ptr, arr._ptr)); return new Array<T>(ptr); }
145+
public static Array Round(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_round(out ptr, arr._ptr)); return new Array(ptr); }
146146

147147
[MethodImpl(MethodImplOptions.AggressiveInlining)]
148-
public static Array<T> Trunc<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_trunc(out ptr, arr._ptr)); return new Array<T>(ptr); }
148+
public static Array Trunc(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_trunc(out ptr, arr._ptr)); return new Array(ptr); }
149149

150150
[MethodImpl(MethodImplOptions.AggressiveInlining)]
151-
public static Array<T> Floor<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_floor(out ptr, arr._ptr)); return new Array<T>(ptr); }
151+
public static Array Floor(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_floor(out ptr, arr._ptr)); return new Array(ptr); }
152152

153153
[MethodImpl(MethodImplOptions.AggressiveInlining)]
154-
public static Array<T> Ceil<T>(Array<T> arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_ceil(out ptr, arr._ptr)); return new Array<T>(ptr); }
154+
public static Array Ceil(Array arr) { IntPtr ptr; Internal.VERIFY(af_arith.af_ceil(out ptr, arr._ptr)); return new Array(ptr); }
155155
#endif
156156

157157
#if _
158158
for (\w+) in
159159
Atan2 Rem Pow
160160
do
161161
[MethodImpl(MethodImplOptions.AggressiveInlining)]
162-
public static Array<T> $1<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_$L1(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
162+
public static Array $1(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_$L1(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
163163
#else
164164
[MethodImpl(MethodImplOptions.AggressiveInlining)]
165-
public static Array<T> Atan2<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_atan2(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
165+
public static Array Atan2(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_atan2(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
166166

167167
[MethodImpl(MethodImplOptions.AggressiveInlining)]
168-
public static Array<T> Rem<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_rem(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
168+
public static Array Rem(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_rem(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
169169

170170
[MethodImpl(MethodImplOptions.AggressiveInlining)]
171-
public static Array<T> Pow<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_pow(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
171+
public static Array Pow(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_pow(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
172172
#endif
173173
#endregion
174174
}

‎Wrapper/Array.cs

Lines changed: 39 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -37,29 +37,35 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3737

3838
namespace ArrayFire
3939
{
40-
public class Array<T> : Arith, IDisposable // we inherit from Arith so the operations in F# Core.Operators module work correctly (e.g. sin, cos, abs)
40+
public class Array : Arith, IDisposable // we inherit from Arith so the operations in F# Core.Operators module work correctly (e.g. sin, cos, abs)
4141
{
42+
private static int _instances = 0;
43+
4244
internal IntPtr _ptr;
4345

4446
internal Array(IntPtr pointer)
4547
{
4648
#if DEBUG
4749
if (pointer == IntPtr.Zero) throw new ArgumentNullException("Invalid Array Pointer");
48-
af_dtype type;
49-
Internal.VERIFY(af_array.af_get_type(out type, pointer));
50-
if(type != Internal.toDType<T>()) throw new ArrayTypeMismatchException("Type mismatch: trying to wrap a " + type.ToString() + " into an Array<" + typeof(T).ToString() + ">");
5150
#endif
5251
this._ptr = pointer;
53-
GCMan.OnAlloc();
52+
Interlocked.Increment(ref _instances);
53+
if (_instances % 50 == 0) // only do it every time we allocated new 50 instances, we can tweak this
54+
{
55+
UIntPtr bytes, buffers, lockbytes, lockbuffers;
56+
Internal.VERIFY(af_device.af_device_mem_info(out bytes, out buffers, out lockbytes, out lockbuffers));
57+
// code borrowed from the R wrapper:
58+
if ((double)lockbytes > Math.Pow(1000, 3) || (double)lockbuffers > 50) GC.Collect();
59+
}
5460
}
5561

56-
#region Sizes and Dimensions
62+
#region Sizes, Dimensions, Type
5763
public int DimCount
5864
{
5965
get
6066
{
6167
uint res;
62-
Internal.VERIFY(af_array.af_get_numdims(out res, _ptr));
68+
Internal.VERIFY(af_array.af_get_numdims(out res, _ptr));
6369
return (int)res;
6470
}
6571
}
@@ -69,7 +75,7 @@ public int ElemCount
6975
get
7076
{
7177
long res;
72-
Internal.VERIFY(af_array.af_get_elements(out res, _ptr));
78+
Internal.VERIFY(af_array.af_get_elements(out res, _ptr));
7379
return (int)res;
7480
}
7581
}
@@ -79,13 +85,23 @@ public Dim4 Dimensions
7985
get
8086
{
8187
long d0, d1, d2, d3;
82-
Internal.VERIFY(af_array.af_get_dims(out d0, out d1, out d2, out d3, _ptr));
88+
Internal.VERIFY(af_array.af_get_dims(out d0, out d1, out d2, out d3, _ptr));
8389
return new Dim4((int)d0, (int)d1, (int)d2, (int)d3);
8490
}
8591
}
86-
#endregion
8792

88-
#region Is___ Properties
93+
public Type ElemType
94+
{
95+
get
96+
{
97+
af_dtype dtype;
98+
Internal.VERIFY(af_array.af_get_type(out dtype, _ptr));
99+
return Internal.toClrType(dtype);
100+
}
101+
}
102+
#endregion
103+
104+
#region Is___ Properties
89105
#if _
90106
for (\w+) in
91107
Empty Scalar Row Column Vector
@@ -98,59 +114,50 @@ Empty Scalar Row Column Vector
98114
public bool IsColumn { get { bool res; Internal.VERIFY(af_array.af_is_column(out res, _ptr)); return res; } }
99115
public bool IsVector { get { bool res; Internal.VERIFY(af_array.af_is_vector(out res, _ptr)); return res; } }
100116
#endif
101-
#endregion
117+
#endregion
102118

103-
#region Operators
119+
#region Operators
104120
#if _
105121
for (\W)(\w+) in
106122
+add -sub *mul /div %mod &bitand |bitor ^bitxor
107123
do
108124
[MethodImpl(MethodImplOptions.AggressiveInlining)]
109-
public static Array<T> operator $1(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_$2(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
125+
public static Array operator $1(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_$2(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
110126
#else
111127
[MethodImpl(MethodImplOptions.AggressiveInlining)]
112-
public static Array<T> operator +(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_add(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
128+
public static Array operator +(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_add(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
113129

114130
[MethodImpl(MethodImplOptions.AggressiveInlining)]
115-
public static Array<T> operator -(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_sub(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
131+
public static Array operator -(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_sub(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
116132

117133
[MethodImpl(MethodImplOptions.AggressiveInlining)]
118-
public static Array<T> operator *(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_mul(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
134+
public static Array operator *(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_mul(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
119135

120136
[MethodImpl(MethodImplOptions.AggressiveInlining)]
121-
public static Array<T> operator /(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_div(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
137+
public static Array operator /(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_div(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
122138

123139
[MethodImpl(MethodImplOptions.AggressiveInlining)]
124-
public static Array<T> operator %(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_mod(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
140+
public static Array operator %(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_mod(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
125141

126142
[MethodImpl(MethodImplOptions.AggressiveInlining)]
127-
public static Array<T> operator &(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitand(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
143+
public static Array operator &(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitand(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
128144

129145
[MethodImpl(MethodImplOptions.AggressiveInlining)]
130-
public static Array<T> operator |(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitor(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
146+
public static Array operator |(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitor(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
131147

132148
[MethodImpl(MethodImplOptions.AggressiveInlining)]
133-
public static Array<T> operator ^(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitxor(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
149+
public static Array operator ^(Array lhs, Array rhs) { IntPtr ptr; Internal.VERIFY(af_arith.af_bitxor(out ptr, lhs._ptr, rhs._ptr, false)); return new Array(ptr); }
134150
#endif
135151
#endregion
136152

137-
#region Casting
138-
public Array<X> Cast<X>()
139-
{
140-
IntPtr ptr;
141-
Internal.VERIFY(af_arith.af_cast(out ptr, _ptr, Internal.toDType<X>()));
142-
return new Array<X>(ptr);
143-
}
144-
#endregion
145-
146153
#region IDisposable Support
147154
protected virtual void Dispose(bool disposing)
148155
{
149156
if (_ptr != IntPtr.Zero)
150157
{
151158
af_array.af_release_array(_ptr);
152159
_ptr = IntPtr.Zero;
153-
GCMan.OnRelease();
160+
Interlocked.Decrement(ref _instances);
154161
}
155162
if (disposing) GC.SuppressFinalize(this);
156163
}

0 commit comments

Comments
 (0)