forked from SciSharp/NumSharp
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathNDArray`1.cs
More file actions
258 lines (229 loc) · 10.4 KB
/
NDArray`1.cs
File metadata and controls
258 lines (229 loc) · 10.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
/*
* NumSharp
* Copyright (C) 2018 Haiping Chen
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the Apache License 2.0 as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the Apache License 2.0
* along with this program. If not, see <http://www.apache.org/licenses/LICENSE-2.0/>.
*/
using System;
using System.Runtime.CompilerServices;
using NumSharp.Backends;
using NumSharp.Backends.Unmanaged;
using NumSharp.Utilities;
// ReSharper disable once CheckNamespace
namespace NumSharp.Generic
{
public partial class NDArray<TDType> : NDArray where TDType : unmanaged
{
/// <summary>
/// Creates a new <see cref="NDArray"/> with this storage.
/// </summary>
/// <param name="storage"></param>
protected internal NDArray(UnmanagedStorage storage) : base(storage)
{
if (storage.DType != typeof(TDType))
throw new ArgumentException($"Storage type must be the same as T. {storage.DType.Name} != {typeof(TDType).Name}", nameof(storage));
}
/// <summary>
/// Creates a new <see cref="NDArray"/> with this storage.
/// </summary>
/// <param name="storage"></param>
protected internal NDArray(UnmanagedStorage storage, Shape shape) : base(storage, shape)
{
if (storage.DType != typeof(TDType))
throw new ArgumentException($"Storage type must be the same as T. {storage.DType.Name} != {typeof(TDType).Name}", nameof(storage));
}
/// <summary>
/// Creates a new <see cref="NDArray"/> with this storage.
/// </summary>
/// <param name="storage"></param>
protected internal NDArray(UnmanagedStorage storage, ref Shape shape) : base(storage, ref shape)
{
if (storage.DType != typeof(TDType))
throw new ArgumentException($"Storage type must be the same as T. {storage.DType.Name} != {typeof(TDType).Name}", nameof(storage));
}
/// <summary>
/// Constructor for init data type
/// internal storage is 1D with 1 element
/// </summary>
/// <param name="dtype">Data type of elements</param>
/// <param name="engine">The engine of this <see cref="NDArray"/></param>
/// <remarks>This constructor does not call allocation/></remarks>
protected internal NDArray(TensorEngine engine) : base(InfoOf<TDType>.NPTypeCode, engine) { }
/// <summary>
/// Constructor for init data type
/// internal storage is 1D with 1 element
/// </summary>
/// <param name="dtype">Data type of elements</param>
/// <remarks>This constructor does not call allocation/></remarks>
public NDArray() : base(InfoOf<TDType>.NPTypeCode) { }
/// <summary>
/// Constructor which initialize elements with length of <paramref name="size"/>
/// </summary>
/// <param name="dtype">Internal data type</param>
/// <param name="size">The size as a single dimension shape</param>
/// <param name="fillZeros">Should set the values of the new allocation to default(dtype)? otherwise - old memory noise</param>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(int size, bool fillZeros) : base(InfoOf<TDType>.NPTypeCode, size, fillZeros)
{ }
/// <summary>
/// Constructor which takes .NET array
/// dtype and shape is determined from array
/// </summary>
/// <param name="values"></param>
/// <param name="shape"></param>
/// <param name="order"></param>
/// <returns>Array with values</returns>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(Array values, Shape shape = default, char order = 'C') : base(values, shape, order)
{
if (dtype != typeof(TDType))
throw new ArgumentException($"Array type must be the same as T. {dtype.Name} != {typeof(TDType).Name}", nameof(values));
}
/// <summary>
/// Constructor which takes .NET array
/// dtype and shape is determined from array
/// </summary>
/// <param name="values"></param>
/// <param name="shape"></param>
/// <param name="order"></param>
/// <returns>Array with values</returns>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(IArraySlice values, Shape shape = default, char order = 'C') : base(values, shape, order)
{
var underlying = values.GetType().GenericTypeArguments[0];
if (underlying != typeof(TDType))
throw new ArgumentException($"Array type must be the same as T. {underlying.Name} != {typeof(TDType).Name}", nameof(values));
}
/// <summary>
/// Constructor which initialize elements with 0
/// type and shape are given.
/// </summary>
/// <param name="shape">Shape of NDArray</param>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(Shape shape) : base(InfoOf<TDType>.NPTypeCode, shape) { }
/// <summary>
/// Constructor which initialize elements with length of <paramref name="size"/>
/// </summary>
/// <param name="size">The size as a single dimension shape</param>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(int size) : base(InfoOf<TDType>.NPTypeCode, size) { }
/// <summary>
/// Constructor which initialize elements with 0
/// type and shape are given.
/// </summary>
/// <param name="dtype">internal data type</param>
/// <param name="shape">Shape of NDArray</param>
/// <param name="fillZeros">Should set the values of the new allocation to default(dtype)? otherwise - old memory noise</param>
/// <remarks>This constructor calls <see cref="IStorage.Allocate(NumSharp.Shape,System.Type)"/></remarks>
public NDArray(Shape shape, bool fillZeros) : base(InfoOf<TDType>.NPTypeCode, shape, fillZeros) { }
/// <summary>
/// Array access to storage data - overridden on purpose
/// </summary>
/// <value></value>
protected internal new ArraySlice<TDType> Array
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => Storage.GetData<TDType>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set => Storage.ReplaceData(value);
}
/// <summary>
/// Gets the address that this NDArray starts from.
/// </summary>
protected internal new unsafe TDType* Address
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => (TDType*)Storage.Address;
}
public new TDType this[params int[] indices]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
if (Shape.IsScalar && indices.Length != 1 || !Shape.IsScalar && indices.Length != ndim)
throw new ArgumentException($"Unable to set an NDArray<{typeof(TDType).Name}> to a non-scalar indices", nameof(indices));
return Storage.GetValue<TDType>(indices);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set
{
if (Shape.IsScalar && indices.Length != 1 || !Shape.IsScalar && indices.Length != ndim)
throw new ArgumentException($"Unable to set an NDArray<{typeof(TDType).Name}> to a non-scalar indices", nameof(indices));
Storage.SetValue<TDType>(value, indices);
}
}
/// <summary>
/// slicing of generic - overridden on purpose
/// </summary>
/// <value></value>
public new NDArray<TDType> this[string slice]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
return base[slice].MakeGeneric<TDType>();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set
{
base[slice] = value;
}
}
/// <summary>
/// slicing of generic - overridden on purpose
/// </summary>
/// <value></value>
public new NDArray<TDType> this[params Slice[] slices]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get => base[slices].MakeGeneric<TDType>();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set => base[slices] = value;
}
public new TDType GetAtIndex(int index)
{
unsafe
{
return *(Address + Shape.TransformOffset(index));
}
}
/// <summary>
/// A 1-D iterator over the array.
/// </summary>
/// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.flat.html</remarks>
public new NDArray<TDType> flat
{
get
{
return base.flat.MakeGeneric<TDType>();
}
}
/// <summary>
/// The transposed array. <br></br>
/// Same as self.transpose().
/// </summary>
/// <remarks>https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.T.html</remarks>
public new NDArray<TDType> T
{
get
{
return transpose().MakeGeneric<TDType>();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator ArraySlice<TDType>(NDArray<TDType> nd) => nd.Array;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator NDArray<TDType>(TDType[] tArray) => new NDArray(tArray).MakeGeneric<TDType>();
}
}