Skip to content

Commit 87bc177

Browse files
royalstreampradeep
royalstream
authored and
pradeep
committed
VS2013 compatibility
1 parent e1854cd commit 87bc177

File tree

11 files changed

+130
-137
lines changed

11 files changed

+130
-137
lines changed

‎ArrayFire/Arith.cs‎

Lines changed: 38 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,6 @@ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3434
using System.Runtime.CompilerServices;
3535

3636
using ArrayFire.Interop;
37-
using static ArrayFire.Global;
3837

3938
namespace ArrayFire
4039
{
@@ -43,7 +42,7 @@ namespace ArrayFire
4342
// we can't make Arith static because Array<T> inherits from it (so the F# Core.Operators free functions work correctly)
4443
protected Arith() { }
4544

46-
#region Mathematical Functions
45+
#region Mathematical Functions
4746
#if _
4847
for (\w+) in
4948
Sin Sinh Asin Asinh
@@ -56,120 +55,120 @@ Abs Sigmoid Factorial
5655
Round Trunc Floor Ceil
5756
do
5857
[MethodImpl(MethodImplOptions.AggressiveInlining)]
59-
public static Array<T> $1<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_$L1(out ptr, arr._ptr)); return new Array<T>(ptr); }
58+
public static Array<T> $1<T>(Array<T> arr) { IntPtr ptr; Global.VERIFY(af_arith.af_$L1(out ptr, arr._ptr)); return new Array<T>(ptr); }
6059
#else
6160
[MethodImpl(MethodImplOptions.AggressiveInlining)]
62-
public static Array<T> Sin<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_sin(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
6362

6463
[MethodImpl(MethodImplOptions.AggressiveInlining)]
65-
public static Array<T> Sinh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_sinh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
6665

6766
[MethodImpl(MethodImplOptions.AggressiveInlining)]
68-
public static Array<T> Asin<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_asin(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
6968

7069
[MethodImpl(MethodImplOptions.AggressiveInlining)]
71-
public static Array<T> Asinh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_asinh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
7271

7372
[MethodImpl(MethodImplOptions.AggressiveInlining)]
74-
public static Array<T> Cos<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_cos(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
7574

7675
[MethodImpl(MethodImplOptions.AggressiveInlining)]
77-
public static Array<T> Cosh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_cosh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
7877

7978
[MethodImpl(MethodImplOptions.AggressiveInlining)]
80-
public static Array<T> Acos<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_acos(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
8180

8281
[MethodImpl(MethodImplOptions.AggressiveInlining)]
83-
public static Array<T> Acosh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_acosh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
8483

8584
[MethodImpl(MethodImplOptions.AggressiveInlining)]
86-
public static Array<T> Tan<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_tan(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
8786

8887
[MethodImpl(MethodImplOptions.AggressiveInlining)]
89-
public static Array<T> Tanh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_tanh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
9089

9190
[MethodImpl(MethodImplOptions.AggressiveInlining)]
92-
public static Array<T> Atan<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_atan(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
9392

9493
[MethodImpl(MethodImplOptions.AggressiveInlining)]
95-
public static Array<T> Atanh<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_atanh(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
9695

9796
[MethodImpl(MethodImplOptions.AggressiveInlining)]
98-
public static Array<T> Exp<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_exp(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
9998

10099
[MethodImpl(MethodImplOptions.AggressiveInlining)]
101-
public static Array<T> Expm1<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_expm1(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
102101

103102
[MethodImpl(MethodImplOptions.AggressiveInlining)]
104-
public static Array<T> Log<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_log(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
105104

106105
[MethodImpl(MethodImplOptions.AggressiveInlining)]
107-
public static Array<T> Log10<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_log10(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
108107

109108
[MethodImpl(MethodImplOptions.AggressiveInlining)]
110-
public static Array<T> Log1p<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_log1p(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
111110

112111
[MethodImpl(MethodImplOptions.AggressiveInlining)]
113-
public static Array<T> Log2<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_log2(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
114113

115114
[MethodImpl(MethodImplOptions.AggressiveInlining)]
116-
public static Array<T> Erf<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_erf(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
117116

118117
[MethodImpl(MethodImplOptions.AggressiveInlining)]
119-
public static Array<T> Erfc<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_erfc(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
120119

121120
[MethodImpl(MethodImplOptions.AggressiveInlining)]
122-
public static Array<T> Sqrt<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_sqrt(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
123122

124123
[MethodImpl(MethodImplOptions.AggressiveInlining)]
125-
public static Array<T> Pow2<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_pow2(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
126125

127126
[MethodImpl(MethodImplOptions.AggressiveInlining)]
128-
public static Array<T> Cbrt<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_cbrt(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
129128

130129
[MethodImpl(MethodImplOptions.AggressiveInlining)]
131-
public static Array<T> LGamma<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_lgamma(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
132131

133132
[MethodImpl(MethodImplOptions.AggressiveInlining)]
134-
public static Array<T> TGamma<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_tgamma(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
135134

136135
[MethodImpl(MethodImplOptions.AggressiveInlining)]
137-
public static Array<T> Abs<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_abs(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
138137

139138
[MethodImpl(MethodImplOptions.AggressiveInlining)]
140-
public static Array<T> Sigmoid<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_sigmoid(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
141140

142141
[MethodImpl(MethodImplOptions.AggressiveInlining)]
143-
public static Array<T> Factorial<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_factorial(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
144143

145144
[MethodImpl(MethodImplOptions.AggressiveInlining)]
146-
public static Array<T> Round<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_round(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
147146

148147
[MethodImpl(MethodImplOptions.AggressiveInlining)]
149-
public static Array<T> Trunc<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_trunc(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
150149

151150
[MethodImpl(MethodImplOptions.AggressiveInlining)]
152-
public static Array<T> Floor<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_floor(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
153152

154153
[MethodImpl(MethodImplOptions.AggressiveInlining)]
155-
public static Array<T> Ceil<T>(Array<T> arr) { IntPtr ptr; VERIFY(af_arith.af_ceil(out ptr, arr._ptr)); return new Array<T>(ptr); }
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); }
156155
#endif
157156

158157
#if _
159158
for (\w+) in
160159
Atan2 Rem Pow
161160
do
162161
[MethodImpl(MethodImplOptions.AggressiveInlining)]
163-
public static Array<T> $1<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; VERIFY(af_arith.af_$L1(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
162+
public static Array<T> $1<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; Global.VERIFY(af_arith.af_$L1(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
164163
#else
165164
[MethodImpl(MethodImplOptions.AggressiveInlining)]
166-
public static Array<T> Atan2<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; VERIFY(af_arith.af_atan2(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
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); }
167166

168167
[MethodImpl(MethodImplOptions.AggressiveInlining)]
169-
public static Array<T> Rem<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; VERIFY(af_arith.af_rem(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
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); }
170169

171170
[MethodImpl(MethodImplOptions.AggressiveInlining)]
172-
public static Array<T> Pow<T>(Array<T> lhs, Array<T> rhs) { IntPtr ptr; VERIFY(af_arith.af_pow(out ptr, lhs._ptr, rhs._ptr, false)); return new Array<T>(ptr); }
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); }
173172
#endif
174173
#endregion
175174
}

0 commit comments

Comments
 (0)