Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/Find.cs @ 9102

Visit:

Last change on this file since 9102 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 67.9 KB

Line
1	///
2	/// This file is part of ILNumerics Community Edition.
3	///
4	/// ILNumerics Community Edition - high performance computing for applications.
5	/// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
6	///
7	/// ILNumerics Community Edition is free software: you can redistribute it and/or modify
8	/// it under the terms of the GNU General Public License version 3 as published by
9	/// the Free Software Foundation.
10	///
11	/// ILNumerics Community Edition is distributed in the hope that it will be useful,
12	/// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	/// GNU General Public License for more details.
15	///
16	/// You should have received a copy of the GNU General Public License
17	/// along with ILNumerics Community Edition. See the file License.txt in the root
18	/// of your distribution package. If not, see <http://www.gnu.org/licenses/>.
19	///
20	/// In addition this software uses the following components and/or licenses:
21	///
22	/// =================================================================================
23	/// The Open Toolkit Library License
24	///
25	/// Copyright (c) 2006 - 2009 the Open Toolkit library.
26	///
27	/// Permission is hereby granted, free of charge, to any person obtaining a copy
28	/// of this software and associated documentation files (the "Software"), to deal
29	/// in the Software without restriction, including without limitation the rights to
30	/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
31	/// the Software, and to permit persons to whom the Software is furnished to do
32	/// so, subject to the following conditions:
33	///
34	/// The above copyright notice and this permission notice shall be included in all
35	/// copies or substantial portions of the Software.
36	///
37	/// =================================================================================
38	///
39
40	using System;
41	using System.Collections.Generic;
42	using System.Text;
43	using ILNumerics.Storage;
44	using ILNumerics.Misc;
45	using ILNumerics.Exceptions;
46
47
48
49	namespace ILNumerics {
50	public partial class ILMath {
51
52
53	/// <summary>
54	/// Find nonzero elements in A
55	/// </summary>
56	/// <param name="A">Input array</param>
57	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
58	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
59	/// Set to 0 to search full array (default).</param>
60	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
61	/// as main return value. C will therefore hold the column indices of those elements. If A
62	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
63	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
64	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
65	/// not null, return value will contain row indices of nonzero elements. </returns>
66	/// <remarks>The return type of the index vectors is always 'double'. The return type
67	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
68	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
69	/// not null also. Any initial data of V or C will be lost.</remarks>
70	public static ILRetArray<double> find(ILInArray< double> A, int limit = 0,
71	ILOutArray<double> C = null, ILOutArray< double> V = null) {
72	using (ILScope.Enter(A)) {
73	bool create_row_columns = !Object.Equals(C, null);
74	bool return_values = !Object.Equals(V, null);
75	ILArray<double> ret = empty();
76	ILSize inDim = A.Size;
77	if (inDim.NumberOfElements == 1) {
78	#region SCALAR
79	// scalar -> return copy
80
81	if (A.GetValue(0, 0) != 0.0) {
82	if (create_row_columns) {
83	C.a = zeros<double>(ILSize.Scalar1_1);
84	}
85	if (return_values) {
86	V.a = A.C;
87	}
88	return zeros<double>(1, 1);
89	} else {
90	if (create_row_columns) {
91	C.a = empty<double>(ILSize.Empty00);
92	}
93	if (return_values) {
94	V.a = empty<double>(ILSize.Empty00);
95	}
96	return empty<double>(ILSize.Empty00);
97	}
98	#endregion SCALAR
99	}
100	long nrElements = inDim.NumberOfElements;
101
102
103	if (limit != 0) {
104	int lim = Math.Abs(limit);
105	if (lim < nrElements)
106	nrElements = lim;
107	}
108	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
109	int foundIdx = 0;
110	// physical -> pointer arithmetic
111	if (limit >= 0) {
112	unsafe {
113	fixed (double* pIndices = indices)
114	fixed ( double* pX = A.GetArrayForRead()) {
115
116	double* lastElement = pX + inDim.NumberOfElements;
117
118	double* tmpIn = pX;
119	double* pI = pIndices;
120	double* pFoundLast = pI + indices.Length;
121	while (tmpIn < lastElement && pI < pFoundLast) {
122
123	if (*tmpIn != 0.0)
124	*pI++ = (double)(tmpIn - pX);
125	tmpIn++;
126	}
127	foundIdx = (int)(pI - pIndices);
128	}
129	}
130	} else {
131	// search backwards
132	unsafe {
133	fixed (double* pIndices = indices)
134	fixed ( double* pX = A.GetArrayForRead()) {
135
136	double* lastElementX = pX;
137
138	double* tmpIn = pX + inDim.NumberOfElements;
139	double* pI = pIndices + indices.Length;
140	while (tmpIn > lastElementX && pI > pIndices) {
141	tmpIn--;
142
143	if (*tmpIn != 0.0)
144	*(--pI) = (double)(tmpIn - pX);
145	}
146	foundIdx = (int)(pIndices + indices.Length - pI);
147	}
148	}
149	}
150	if (foundIdx == 0) {
151	return empty();
152	}
153	// transform to row / columns; extract values if needed
154	int leadDimLen = inDim[0];
155	if (create_row_columns) {
156	#region RETURN ROWS / COLUMNS /VALUES
157	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
158	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
159	if (return_values) {
160	V.a = new ILRetArray< double>(ILMemoryPool.Pool.New< double>(foundIdx), foundIdx, 1);
161	// copy values, transform to row/columns
162	unsafe {
163	fixed (double* pIndices = indices,
164	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
165	fixed ( double* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
166	double* pI = (limit >= 0) ?
167	pIndices : (pIndices + indices.Length - foundIdx);
168	double* pLastIndex = pI + foundIdx;
169	double* pR = pRows;
170	double* pC = pCols;
171
172	double* pV = pValues;
173
174	double* pX = pInput;
175	while (pI < pLastIndex) {
176	pR++ = (pI) % leadDimLen;
177	pC++ = (int)(pI) / leadDimLen;
178	pV++ = (pInput + (int)*pI++);
179	}
180	}
181	}
182	} else {
183	// just return row / columns
184	unsafe {
185	fixed (double* pIndices = indices,
186	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
187	fixed ( double* pInput = A.GetArrayForRead()) {
188	double* pI = (limit >= 0) ?
189	pIndices : (pIndices + indices.Length - foundIdx);
190	double* pLastIndex = pI + foundIdx;
191	double* pR = pRows;
192	double* pC = pCols;
193	while (pI < pLastIndex) {
194	pR++ = (pI) % leadDimLen;
195	pC++ = (int)((pI++) / leadDimLen);
196	}
197	}
198	}
199	}
200	#endregion RETURN ROWS / COLUMNS
201	} else {
202	#region RETURN INDICES ONLY
203	if (foundIdx != indices.Length) {
204	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
205	unsafe {
206	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
207	double* pI = (limit >= 0) ?
208	pIndices : (pIndices + indices.Length - foundIdx);
209	double* pLastIndex = pI + foundIdx;
210	double* pR = pRows;
211	while (pI < pLastIndex) {
212	pR++ = pI++;
213	}
214	}
215	}
216	} else {
217	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
218	}
219	#endregion RETURN INDICES ONLY
220	}
221	return ret;
222	}
223	}
224
225	#region HYCALPER AUTO GENERATED CODE
226
227	/// <summary>
228	/// Find nonzero elements in A
229	/// </summary>
230	/// <param name="A">Input array</param>
231	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
232	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
233	/// Set to 0 to search full array (default).</param>
234	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
235	/// as main return value. C will therefore hold the column indices of those elements. If A
236	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
237	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
238	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
239	/// not null, return value will contain row indices of nonzero elements. </returns>
240	/// <remarks>The return type of the index vectors is always 'double'. The return type
241	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
242	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
243	/// not null also. Any initial data of V or C will be lost.</remarks>
244	public static ILRetArray<double> find(ILInArray< Int64> A, int limit = 0,
245	ILOutArray<double> C = null, ILOutArray< Int64> V = null) {
246	using (ILScope.Enter(A)) {
247	bool create_row_columns = !Object.Equals(C, null);
248	bool return_values = !Object.Equals(V, null);
249	ILArray<double> ret = empty();
250	ILSize inDim = A.Size;
251	if (inDim.NumberOfElements == 1) {
252	#region SCALAR
253	// scalar -> return copy
254	if (A.GetValue(0,0) != 0) {
255	if (create_row_columns) {
256	C.a = zeros<double>(ILSize.Scalar1_1);
257	}
258	if (return_values) {
259	V.a = A.C;
260	}
261	return zeros<double>(1, 1);
262	} else {
263	if (create_row_columns) {
264	C.a = empty<double>(ILSize.Empty00);
265	}
266	if (return_values) {
267	V.a = empty<Int64>(ILSize.Empty00);
268	}
269	return empty<double>(ILSize.Empty00);
270	}
271	#endregion SCALAR
272	}
273	long nrElements = inDim.NumberOfElements;
274
275	if (limit != 0) {
276	int lim = Math.Abs(limit);
277	if (lim < nrElements)
278	nrElements = lim;
279	}
280	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
281	int foundIdx = 0;
282	// physical -> pointer arithmetic
283	if (limit >= 0) {
284	unsafe {
285	fixed (double* pIndices = indices)
286	fixed ( Int64* pX = A.GetArrayForRead()) {
287
288	Int64* lastElement = pX + inDim.NumberOfElements;
289
290	Int64* tmpIn = pX;
291	double* pI = pIndices;
292	double* pFoundLast = pI + indices.Length;
293	while (tmpIn < lastElement && pI < pFoundLast) {
294	if (*tmpIn != 0)
295	*pI++ = (double)(tmpIn - pX);
296	tmpIn++;
297	}
298	foundIdx = (int)(pI - pIndices);
299	}
300	}
301	} else {
302	// search backwards
303	unsafe {
304	fixed (double* pIndices = indices)
305	fixed ( Int64* pX = A.GetArrayForRead()) {
306
307	Int64* lastElementX = pX;
308
309	Int64* tmpIn = pX + inDim.NumberOfElements;
310	double* pI = pIndices + indices.Length;
311	while (tmpIn > lastElementX && pI > pIndices) {
312	tmpIn--;
313	if (*tmpIn != 0)
314	*(--pI) = (double)(tmpIn - pX);
315	}
316	foundIdx = (int)(pIndices + indices.Length - pI);
317	}
318	}
319	}
320	if (foundIdx == 0) {
321	return empty();
322	}
323	// transform to row / columns; extract values if needed
324	int leadDimLen = inDim[0];
325	if (create_row_columns) {
326	#region RETURN ROWS / COLUMNS /VALUES
327	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
328	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
329	if (return_values) {
330	V.a = new ILRetArray< Int64>(ILMemoryPool.Pool.New< Int64>(foundIdx), foundIdx, 1);
331	// copy values, transform to row/columns
332	unsafe {
333	fixed (double* pIndices = indices,
334	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
335	fixed ( Int64* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
336	double* pI = (limit >= 0) ?
337	pIndices : (pIndices + indices.Length - foundIdx);
338	double* pLastIndex = pI + foundIdx;
339	double* pR = pRows;
340	double* pC = pCols;
341
342	Int64* pV = pValues;
343
344	Int64* pX = pInput;
345	while (pI < pLastIndex) {
346	pR++ = (pI) % leadDimLen;
347	pC++ = (int)(pI) / leadDimLen;
348	pV++ = (pInput + (int)*pI++);
349	}
350	}
351	}
352	} else {
353	// just return row / columns
354	unsafe {
355	fixed (double* pIndices = indices,
356	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
357	fixed ( Int64* pInput = A.GetArrayForRead()) {
358	double* pI = (limit >= 0) ?
359	pIndices : (pIndices + indices.Length - foundIdx);
360	double* pLastIndex = pI + foundIdx;
361	double* pR = pRows;
362	double* pC = pCols;
363	while (pI < pLastIndex) {
364	pR++ = (pI) % leadDimLen;
365	pC++ = (int)((pI++) / leadDimLen);
366	}
367	}
368	}
369	}
370	#endregion RETURN ROWS / COLUMNS
371	} else {
372	#region RETURN INDICES ONLY
373	if (foundIdx != indices.Length) {
374	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
375	unsafe {
376	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
377	double* pI = (limit >= 0) ?
378	pIndices : (pIndices + indices.Length - foundIdx);
379	double* pLastIndex = pI + foundIdx;
380	double* pR = pRows;
381	while (pI < pLastIndex) {
382	pR++ = pI++;
383	}
384	}
385	}
386	} else {
387	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
388	}
389	#endregion RETURN INDICES ONLY
390	}
391	return ret;
392	}
393	}
394	/// <summary>
395	/// Find nonzero elements in A
396	/// </summary>
397	/// <param name="A">Input array</param>
398	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
399	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
400	/// Set to 0 to search full array (default).</param>
401	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
402	/// as main return value. C will therefore hold the column indices of those elements. If A
403	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
404	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
405	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
406	/// not null, return value will contain row indices of nonzero elements. </returns>
407	/// <remarks>The return type of the index vectors is always 'double'. The return type
408	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
409	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
410	/// not null also. Any initial data of V or C will be lost.</remarks>
411	public static ILRetArray<double> find(ILInArray< Int32> A, int limit = 0,
412	ILOutArray<double> C = null, ILOutArray< Int32> V = null) {
413	using (ILScope.Enter(A)) {
414	bool create_row_columns = !Object.Equals(C, null);
415	bool return_values = !Object.Equals(V, null);
416	ILArray<double> ret = empty();
417	ILSize inDim = A.Size;
418	if (inDim.NumberOfElements == 1) {
419	#region SCALAR
420	// scalar -> return copy
421	if (A.GetValue(0,0) != 0) {
422	if (create_row_columns) {
423	C.a = zeros<double>(ILSize.Scalar1_1);
424	}
425	if (return_values) {
426	V.a = A.C;
427	}
428	return zeros<double>(1, 1);
429	} else {
430	if (create_row_columns) {
431	C.a = empty<double>(ILSize.Empty00);
432	}
433	if (return_values) {
434	V.a = empty<Int32>(ILSize.Empty00);
435	}
436	return empty<double>(ILSize.Empty00);
437	}
438	#endregion SCALAR
439	}
440	long nrElements = inDim.NumberOfElements;
441
442	if (limit != 0) {
443	int lim = Math.Abs(limit);
444	if (lim < nrElements)
445	nrElements = lim;
446	}
447	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
448	int foundIdx = 0;
449	// physical -> pointer arithmetic
450	if (limit >= 0) {
451	unsafe {
452	fixed (double* pIndices = indices)
453	fixed ( Int32* pX = A.GetArrayForRead()) {
454
455	Int32* lastElement = pX + inDim.NumberOfElements;
456
457	Int32* tmpIn = pX;
458	double* pI = pIndices;
459	double* pFoundLast = pI + indices.Length;
460	while (tmpIn < lastElement && pI < pFoundLast) {
461	if (*tmpIn != 0)
462	*pI++ = (double)(tmpIn - pX);
463	tmpIn++;
464	}
465	foundIdx = (int)(pI - pIndices);
466	}
467	}
468	} else {
469	// search backwards
470	unsafe {
471	fixed (double* pIndices = indices)
472	fixed ( Int32* pX = A.GetArrayForRead()) {
473
474	Int32* lastElementX = pX;
475
476	Int32* tmpIn = pX + inDim.NumberOfElements;
477	double* pI = pIndices + indices.Length;
478	while (tmpIn > lastElementX && pI > pIndices) {
479	tmpIn--;
480	if (*tmpIn != 0)
481	*(--pI) = (double)(tmpIn - pX);
482	}
483	foundIdx = (int)(pIndices + indices.Length - pI);
484	}
485	}
486	}
487	if (foundIdx == 0) {
488	return empty();
489	}
490	// transform to row / columns; extract values if needed
491	int leadDimLen = inDim[0];
492	if (create_row_columns) {
493	#region RETURN ROWS / COLUMNS /VALUES
494	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
495	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
496	if (return_values) {
497	V.a = new ILRetArray< Int32>(ILMemoryPool.Pool.New< Int32>(foundIdx), foundIdx, 1);
498	// copy values, transform to row/columns
499	unsafe {
500	fixed (double* pIndices = indices,
501	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
502	fixed ( Int32* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
503	double* pI = (limit >= 0) ?
504	pIndices : (pIndices + indices.Length - foundIdx);
505	double* pLastIndex = pI + foundIdx;
506	double* pR = pRows;
507	double* pC = pCols;
508
509	Int32* pV = pValues;
510
511	Int32* pX = pInput;
512	while (pI < pLastIndex) {
513	pR++ = (pI) % leadDimLen;
514	pC++ = (int)(pI) / leadDimLen;
515	pV++ = (pInput + (int)*pI++);
516	}
517	}
518	}
519	} else {
520	// just return row / columns
521	unsafe {
522	fixed (double* pIndices = indices,
523	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
524	fixed ( Int32* pInput = A.GetArrayForRead()) {
525	double* pI = (limit >= 0) ?
526	pIndices : (pIndices + indices.Length - foundIdx);
527	double* pLastIndex = pI + foundIdx;
528	double* pR = pRows;
529	double* pC = pCols;
530	while (pI < pLastIndex) {
531	pR++ = (pI) % leadDimLen;
532	pC++ = (int)((pI++) / leadDimLen);
533	}
534	}
535	}
536	}
537	#endregion RETURN ROWS / COLUMNS
538	} else {
539	#region RETURN INDICES ONLY
540	if (foundIdx != indices.Length) {
541	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
542	unsafe {
543	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
544	double* pI = (limit >= 0) ?
545	pIndices : (pIndices + indices.Length - foundIdx);
546	double* pLastIndex = pI + foundIdx;
547	double* pR = pRows;
548	while (pI < pLastIndex) {
549	pR++ = pI++;
550	}
551	}
552	}
553	} else {
554	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
555	}
556	#endregion RETURN INDICES ONLY
557	}
558	return ret;
559	}
560	}
561	/// <summary>
562	/// Find nonzero elements in A
563	/// </summary>
564	/// <param name="A">Input array</param>
565	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
566	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
567	/// Set to 0 to search full array (default).</param>
568	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
569	/// as main return value. C will therefore hold the column indices of those elements. If A
570	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
571	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
572	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
573	/// not null, return value will contain row indices of nonzero elements. </returns>
574	/// <remarks>The return type of the index vectors is always 'double'. The return type
575	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
576	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
577	/// not null also. Any initial data of V or C will be lost.</remarks>
578	public static ILRetArray<double> find(ILInArray< float> A, int limit = 0,
579	ILOutArray<double> C = null, ILOutArray< float> V = null) {
580	using (ILScope.Enter(A)) {
581	bool create_row_columns = !Object.Equals(C, null);
582	bool return_values = !Object.Equals(V, null);
583	ILArray<double> ret = empty();
584	ILSize inDim = A.Size;
585	if (inDim.NumberOfElements == 1) {
586	#region SCALAR
587	// scalar -> return copy
588	if (A.GetValue(0,0) != 0.0) {
589	if (create_row_columns) {
590	C.a = zeros<double>(ILSize.Scalar1_1);
591	}
592	if (return_values) {
593	V.a = A.C;
594	}
595	return zeros<double>(1, 1);
596	} else {
597	if (create_row_columns) {
598	C.a = empty<double>(ILSize.Empty00);
599	}
600	if (return_values) {
601	V.a = empty<float>(ILSize.Empty00);
602	}
603	return empty<double>(ILSize.Empty00);
604	}
605	#endregion SCALAR
606	}
607	long nrElements = inDim.NumberOfElements;
608
609	if (limit != 0) {
610	int lim = Math.Abs(limit);
611	if (lim < nrElements)
612	nrElements = lim;
613	}
614	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
615	int foundIdx = 0;
616	// physical -> pointer arithmetic
617	if (limit >= 0) {
618	unsafe {
619	fixed (double* pIndices = indices)
620	fixed ( float* pX = A.GetArrayForRead()) {
621
622	float* lastElement = pX + inDim.NumberOfElements;
623
624	float* tmpIn = pX;
625	double* pI = pIndices;
626	double* pFoundLast = pI + indices.Length;
627	while (tmpIn < lastElement && pI < pFoundLast) {
628	if (*tmpIn != 0.0f)
629	*pI++ = (double)(tmpIn - pX);
630	tmpIn++;
631	}
632	foundIdx = (int)(pI - pIndices);
633	}
634	}
635	} else {
636	// search backwards
637	unsafe {
638	fixed (double* pIndices = indices)
639	fixed ( float* pX = A.GetArrayForRead()) {
640
641	float* lastElementX = pX;
642
643	float* tmpIn = pX + inDim.NumberOfElements;
644	double* pI = pIndices + indices.Length;
645	while (tmpIn > lastElementX && pI > pIndices) {
646	tmpIn--;
647	if (*tmpIn != 0.0f)
648	*(--pI) = (double)(tmpIn - pX);
649	}
650	foundIdx = (int)(pIndices + indices.Length - pI);
651	}
652	}
653	}
654	if (foundIdx == 0) {
655	return empty();
656	}
657	// transform to row / columns; extract values if needed
658	int leadDimLen = inDim[0];
659	if (create_row_columns) {
660	#region RETURN ROWS / COLUMNS /VALUES
661	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
662	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
663	if (return_values) {
664	V.a = new ILRetArray< float>(ILMemoryPool.Pool.New< float>(foundIdx), foundIdx, 1);
665	// copy values, transform to row/columns
666	unsafe {
667	fixed (double* pIndices = indices,
668	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
669	fixed ( float* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
670	double* pI = (limit >= 0) ?
671	pIndices : (pIndices + indices.Length - foundIdx);
672	double* pLastIndex = pI + foundIdx;
673	double* pR = pRows;
674	double* pC = pCols;
675
676	float* pV = pValues;
677
678	float* pX = pInput;
679	while (pI < pLastIndex) {
680	pR++ = (pI) % leadDimLen;
681	pC++ = (int)(pI) / leadDimLen;
682	pV++ = (pInput + (int)*pI++);
683	}
684	}
685	}
686	} else {
687	// just return row / columns
688	unsafe {
689	fixed (double* pIndices = indices,
690	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
691	fixed ( float* pInput = A.GetArrayForRead()) {
692	double* pI = (limit >= 0) ?
693	pIndices : (pIndices + indices.Length - foundIdx);
694	double* pLastIndex = pI + foundIdx;
695	double* pR = pRows;
696	double* pC = pCols;
697	while (pI < pLastIndex) {
698	pR++ = (pI) % leadDimLen;
699	pC++ = (int)((pI++) / leadDimLen);
700	}
701	}
702	}
703	}
704	#endregion RETURN ROWS / COLUMNS
705	} else {
706	#region RETURN INDICES ONLY
707	if (foundIdx != indices.Length) {
708	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
709	unsafe {
710	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
711	double* pI = (limit >= 0) ?
712	pIndices : (pIndices + indices.Length - foundIdx);
713	double* pLastIndex = pI + foundIdx;
714	double* pR = pRows;
715	while (pI < pLastIndex) {
716	pR++ = pI++;
717	}
718	}
719	}
720	} else {
721	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
722	}
723	#endregion RETURN INDICES ONLY
724	}
725	return ret;
726	}
727	}
728	/// <summary>
729	/// Find nonzero elements in A
730	/// </summary>
731	/// <param name="A">Input array</param>
732	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
733	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
734	/// Set to 0 to search full array (default).</param>
735	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
736	/// as main return value. C will therefore hold the column indices of those elements. If A
737	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
738	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
739	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
740	/// not null, return value will contain row indices of nonzero elements. </returns>
741	/// <remarks>The return type of the index vectors is always 'double'. The return type
742	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
743	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
744	/// not null also. Any initial data of V or C will be lost.</remarks>
745	public static ILRetArray<double> find(ILInArray< fcomplex> A, int limit = 0,
746	ILOutArray<double> C = null, ILOutArray< fcomplex> V = null) {
747	using (ILScope.Enter(A)) {
748	bool create_row_columns = !Object.Equals(C, null);
749	bool return_values = !Object.Equals(V, null);
750	ILArray<double> ret = empty();
751	ILSize inDim = A.Size;
752	if (inDim.NumberOfElements == 1) {
753	#region SCALAR
754	// scalar -> return copy
755	if (A.GetValue(0,0).real != 0.0 \|\| A.GetValue(0,0).imag != 0.0) {
756	if (create_row_columns) {
757	C.a = zeros<double>(ILSize.Scalar1_1);
758	}
759	if (return_values) {
760	V.a = A.C;
761	}
762	return zeros<double>(1, 1);
763	} else {
764	if (create_row_columns) {
765	C.a = empty<double>(ILSize.Empty00);
766	}
767	if (return_values) {
768	V.a = empty<fcomplex>(ILSize.Empty00);
769	}
770	return empty<double>(ILSize.Empty00);
771	}
772	#endregion SCALAR
773	}
774	long nrElements = inDim.NumberOfElements;
775
776	if (limit != 0) {
777	int lim = Math.Abs(limit);
778	if (lim < nrElements)
779	nrElements = lim;
780	}
781	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
782	int foundIdx = 0;
783	// physical -> pointer arithmetic
784	if (limit >= 0) {
785	unsafe {
786	fixed (double* pIndices = indices)
787	fixed ( fcomplex* pX = A.GetArrayForRead()) {
788
789	fcomplex* lastElement = pX + inDim.NumberOfElements;
790
791	fcomplex* tmpIn = pX;
792	double* pI = pIndices;
793	double* pFoundLast = pI + indices.Length;
794	while (tmpIn < lastElement && pI < pFoundLast) {
795	if ((tmpIn).real != 0.0 \|\| (tmpIn).imag != 0.0)
796	*pI++ = (double)(tmpIn - pX);
797	tmpIn++;
798	}
799	foundIdx = (int)(pI - pIndices);
800	}
801	}
802	} else {
803	// search backwards
804	unsafe {
805	fixed (double* pIndices = indices)
806	fixed ( fcomplex* pX = A.GetArrayForRead()) {
807
808	fcomplex* lastElementX = pX;
809
810	fcomplex* tmpIn = pX + inDim.NumberOfElements;
811	double* pI = pIndices + indices.Length;
812	while (tmpIn > lastElementX && pI > pIndices) {
813	tmpIn--;
814	if ((tmpIn).real != 0.0 \|\| (tmpIn).imag != 0.0)
815	*(--pI) = (double)(tmpIn - pX);
816	}
817	foundIdx = (int)(pIndices + indices.Length - pI);
818	}
819	}
820	}
821	if (foundIdx == 0) {
822	return empty();
823	}
824	// transform to row / columns; extract values if needed
825	int leadDimLen = inDim[0];
826	if (create_row_columns) {
827	#region RETURN ROWS / COLUMNS /VALUES
828	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
829	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
830	if (return_values) {
831	V.a = new ILRetArray< fcomplex>(ILMemoryPool.Pool.New< fcomplex>(foundIdx), foundIdx, 1);
832	// copy values, transform to row/columns
833	unsafe {
834	fixed (double* pIndices = indices,
835	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
836	fixed ( fcomplex* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
837	double* pI = (limit >= 0) ?
838	pIndices : (pIndices + indices.Length - foundIdx);
839	double* pLastIndex = pI + foundIdx;
840	double* pR = pRows;
841	double* pC = pCols;
842
843	fcomplex* pV = pValues;
844
845	fcomplex* pX = pInput;
846	while (pI < pLastIndex) {
847	pR++ = (pI) % leadDimLen;
848	pC++ = (int)(pI) / leadDimLen;
849	pV++ = (pInput + (int)*pI++);
850	}
851	}
852	}
853	} else {
854	// just return row / columns
855	unsafe {
856	fixed (double* pIndices = indices,
857	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
858	fixed ( fcomplex* pInput = A.GetArrayForRead()) {
859	double* pI = (limit >= 0) ?
860	pIndices : (pIndices + indices.Length - foundIdx);
861	double* pLastIndex = pI + foundIdx;
862	double* pR = pRows;
863	double* pC = pCols;
864	while (pI < pLastIndex) {
865	pR++ = (pI) % leadDimLen;
866	pC++ = (int)((pI++) / leadDimLen);
867	}
868	}
869	}
870	}
871	#endregion RETURN ROWS / COLUMNS
872	} else {
873	#region RETURN INDICES ONLY
874	if (foundIdx != indices.Length) {
875	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
876	unsafe {
877	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
878	double* pI = (limit >= 0) ?
879	pIndices : (pIndices + indices.Length - foundIdx);
880	double* pLastIndex = pI + foundIdx;
881	double* pR = pRows;
882	while (pI < pLastIndex) {
883	pR++ = pI++;
884	}
885	}
886	}
887	} else {
888	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
889	}
890	#endregion RETURN INDICES ONLY
891	}
892	return ret;
893	}
894	}
895	/// <summary>
896	/// Find nonzero elements in A
897	/// </summary>
898	/// <param name="A">Input array</param>
899	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
900	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
901	/// Set to 0 to search full array (default).</param>
902	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
903	/// as main return value. C will therefore hold the column indices of those elements. If A
904	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
905	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
906	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
907	/// not null, return value will contain row indices of nonzero elements. </returns>
908	/// <remarks>The return type of the index vectors is always 'double'. The return type
909	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
910	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
911	/// not null also. Any initial data of V or C will be lost.</remarks>
912	public static ILRetArray<double> find(ILInArray< complex> A, int limit = 0,
913	ILOutArray<double> C = null, ILOutArray< complex> V = null) {
914	using (ILScope.Enter(A)) {
915	bool create_row_columns = !Object.Equals(C, null);
916	bool return_values = !Object.Equals(V, null);
917	ILArray<double> ret = empty();
918	ILSize inDim = A.Size;
919	if (inDim.NumberOfElements == 1) {
920	#region SCALAR
921	// scalar -> return copy
922	if (A.GetValue(0,0).real != 0.0 \|\| A.GetValue(0,0).imag != 0.0) {
923	if (create_row_columns) {
924	C.a = zeros<double>(ILSize.Scalar1_1);
925	}
926	if (return_values) {
927	V.a = A.C;
928	}
929	return zeros<double>(1, 1);
930	} else {
931	if (create_row_columns) {
932	C.a = empty<double>(ILSize.Empty00);
933	}
934	if (return_values) {
935	V.a = empty<complex>(ILSize.Empty00);
936	}
937	return empty<double>(ILSize.Empty00);
938	}
939	#endregion SCALAR
940	}
941	long nrElements = inDim.NumberOfElements;
942
943	if (limit != 0) {
944	int lim = Math.Abs(limit);
945	if (lim < nrElements)
946	nrElements = lim;
947	}
948	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
949	int foundIdx = 0;
950	// physical -> pointer arithmetic
951	if (limit >= 0) {
952	unsafe {
953	fixed (double* pIndices = indices)
954	fixed ( complex* pX = A.GetArrayForRead()) {
955
956	complex* lastElement = pX + inDim.NumberOfElements;
957
958	complex* tmpIn = pX;
959	double* pI = pIndices;
960	double* pFoundLast = pI + indices.Length;
961	while (tmpIn < lastElement && pI < pFoundLast) {
962	if ((tmpIn).real != 0.0 \|\| (tmpIn).imag != 0.0)
963	*pI++ = (double)(tmpIn - pX);
964	tmpIn++;
965	}
966	foundIdx = (int)(pI - pIndices);
967	}
968	}
969	} else {
970	// search backwards
971	unsafe {
972	fixed (double* pIndices = indices)
973	fixed ( complex* pX = A.GetArrayForRead()) {
974
975	complex* lastElementX = pX;
976
977	complex* tmpIn = pX + inDim.NumberOfElements;
978	double* pI = pIndices + indices.Length;
979	while (tmpIn > lastElementX && pI > pIndices) {
980	tmpIn--;
981	if ((tmpIn).real != 0.0 \|\| (tmpIn).imag != 0.0)
982	*(--pI) = (double)(tmpIn - pX);
983	}
984	foundIdx = (int)(pIndices + indices.Length - pI);
985	}
986	}
987	}
988	if (foundIdx == 0) {
989	return empty();
990	}
991	// transform to row / columns; extract values if needed
992	int leadDimLen = inDim[0];
993	if (create_row_columns) {
994	#region RETURN ROWS / COLUMNS /VALUES
995	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
996	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
997	if (return_values) {
998	V.a = new ILRetArray< complex>(ILMemoryPool.Pool.New< complex>(foundIdx), foundIdx, 1);
999	// copy values, transform to row/columns
1000	unsafe {
1001	fixed (double* pIndices = indices,
1002	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
1003	fixed ( complex* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
1004	double* pI = (limit >= 0) ?
1005	pIndices : (pIndices + indices.Length - foundIdx);
1006	double* pLastIndex = pI + foundIdx;
1007	double* pR = pRows;
1008	double* pC = pCols;
1009
1010	complex* pV = pValues;
1011
1012	complex* pX = pInput;
1013	while (pI < pLastIndex) {
1014	pR++ = (pI) % leadDimLen;
1015	pC++ = (int)(pI) / leadDimLen;
1016	pV++ = (pInput + (int)*pI++);
1017	}
1018	}
1019	}
1020	} else {
1021	// just return row / columns
1022	unsafe {
1023	fixed (double* pIndices = indices,
1024	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
1025	fixed ( complex* pInput = A.GetArrayForRead()) {
1026	double* pI = (limit >= 0) ?
1027	pIndices : (pIndices + indices.Length - foundIdx);
1028	double* pLastIndex = pI + foundIdx;
1029	double* pR = pRows;
1030	double* pC = pCols;
1031	while (pI < pLastIndex) {
1032	pR++ = (pI) % leadDimLen;
1033	pC++ = (int)((pI++) / leadDimLen);
1034	}
1035	}
1036	}
1037	}
1038	#endregion RETURN ROWS / COLUMNS
1039	} else {
1040	#region RETURN INDICES ONLY
1041	if (foundIdx != indices.Length) {
1042	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
1043	unsafe {
1044	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
1045	double* pI = (limit >= 0) ?
1046	pIndices : (pIndices + indices.Length - foundIdx);
1047	double* pLastIndex = pI + foundIdx;
1048	double* pR = pRows;
1049	while (pI < pLastIndex) {
1050	pR++ = pI++;
1051	}
1052	}
1053	}
1054	} else {
1055	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
1056	}
1057	#endregion RETURN INDICES ONLY
1058	}
1059	return ret;
1060	}
1061	}
1062	/// <summary>
1063	/// Find nonzero elements in A
1064	/// </summary>
1065	/// <param name="A">Input array</param>
1066	/// <param name="limit">[Optional] Number of elements to search for. If this value is <![CDATA[< 0]]> the function
1067	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
1068	/// Set to 0 to search full array (default).</param>
1069	/// <param name="C">[Optional] If not null, the function will return the row indices of nonzero elements
1070	/// as main return value. C will therefore hold the column indices of those elements. If A
1071	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
1072	/// <param name="V">[Optional] If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
1073	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
1074	/// not null, return value will contain row indices of nonzero elements. </returns>
1075	/// <remarks>The return type of the index vectors is always 'double'. The return type
1076	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
1077	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
1078	/// not null also. Any initial data of V or C will be lost.</remarks>
1079	public static ILRetArray<double> find(ILInArray< byte> A, int limit = 0,
1080	ILOutArray<double> C = null, ILOutArray< byte> V = null) {
1081	using (ILScope.Enter(A)) {
1082	bool create_row_columns = !Object.Equals(C, null);
1083	bool return_values = !Object.Equals(V, null);
1084	ILArray<double> ret = empty();
1085	ILSize inDim = A.Size;
1086	if (inDim.NumberOfElements == 1) {
1087	#region SCALAR
1088	// scalar -> return copy
1089	if (A.GetValue(0,0) != 0) {
1090	if (create_row_columns) {
1091	C.a = zeros<double>(ILSize.Scalar1_1);
1092	}
1093	if (return_values) {
1094	V.a = A.C;
1095	}
1096	return zeros<double>(1, 1);
1097	} else {
1098	if (create_row_columns) {
1099	C.a = empty<double>(ILSize.Empty00);
1100	}
1101	if (return_values) {
1102	V.a = empty<byte>(ILSize.Empty00);
1103	}
1104	return empty<double>(ILSize.Empty00);
1105	}
1106	#endregion SCALAR
1107	}
1108	long nrElements = inDim.NumberOfElements;
1109
1110	if (limit != 0) {
1111	int lim = Math.Abs(limit);
1112	if (lim < nrElements)
1113	nrElements = lim;
1114	}
1115	double[] indices = ILMemoryPool.Pool.New<double>(nrElements); // init return array with most elements for non logical inarray -> shorten afterwards
1116	int foundIdx = 0;
1117	// physical -> pointer arithmetic
1118	if (limit >= 0) {
1119	unsafe {
1120	fixed (double* pIndices = indices)
1121	fixed ( byte* pX = A.GetArrayForRead()) {
1122
1123	byte* lastElement = pX + inDim.NumberOfElements;
1124
1125	byte* tmpIn = pX;
1126	double* pI = pIndices;
1127	double* pFoundLast = pI + indices.Length;
1128	while (tmpIn < lastElement && pI < pFoundLast) {
1129	if (*tmpIn != 0)
1130	*pI++ = (double)(tmpIn - pX);
1131	tmpIn++;
1132	}
1133	foundIdx = (int)(pI - pIndices);
1134	}
1135	}
1136	} else {
1137	// search backwards
1138	unsafe {
1139	fixed (double* pIndices = indices)
1140	fixed ( byte* pX = A.GetArrayForRead()) {
1141
1142	byte* lastElementX = pX;
1143
1144	byte* tmpIn = pX + inDim.NumberOfElements;
1145	double* pI = pIndices + indices.Length;
1146	while (tmpIn > lastElementX && pI > pIndices) {
1147	tmpIn--;
1148	if (*tmpIn != 0)
1149	*(--pI) = (double)(tmpIn - pX);
1150	}
1151	foundIdx = (int)(pIndices + indices.Length - pI);
1152	}
1153	}
1154	}
1155	if (foundIdx == 0) {
1156	return empty();
1157	}
1158	// transform to row / columns; extract values if needed
1159	int leadDimLen = inDim[0];
1160	if (create_row_columns) {
1161	#region RETURN ROWS / COLUMNS /VALUES
1162	C.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
1163	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
1164	if (return_values) {
1165	V.a = new ILRetArray< byte>(ILMemoryPool.Pool.New< byte>(foundIdx), foundIdx, 1);
1166	// copy values, transform to row/columns
1167	unsafe {
1168	fixed (double* pIndices = indices,
1169	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
1170	fixed ( byte* pValues = V.GetArrayForWrite(), pInput = A.GetArrayForRead()) {
1171	double* pI = (limit >= 0) ?
1172	pIndices : (pIndices + indices.Length - foundIdx);
1173	double* pLastIndex = pI + foundIdx;
1174	double* pR = pRows;
1175	double* pC = pCols;
1176
1177	byte* pV = pValues;
1178
1179	byte* pX = pInput;
1180	while (pI < pLastIndex) {
1181	pR++ = (pI) % leadDimLen;
1182	pC++ = (int)(pI) / leadDimLen;
1183	pV++ = (pInput + (int)*pI++);
1184	}
1185	}
1186	}
1187	} else {
1188	// just return row / columns
1189	unsafe {
1190	fixed (double* pIndices = indices,
1191	pRows = ret.GetArrayForWrite(), pCols = C.GetArrayForWrite())
1192	fixed ( byte* pInput = A.GetArrayForRead()) {
1193	double* pI = (limit >= 0) ?
1194	pIndices : (pIndices + indices.Length - foundIdx);
1195	double* pLastIndex = pI + foundIdx;
1196	double* pR = pRows;
1197	double* pC = pCols;
1198	while (pI < pLastIndex) {
1199	pR++ = (pI) % leadDimLen;
1200	pC++ = (int)((pI++) / leadDimLen);
1201	}
1202	}
1203	}
1204	}
1205	#endregion RETURN ROWS / COLUMNS
1206	} else {
1207	#region RETURN INDICES ONLY
1208	if (foundIdx != indices.Length) {
1209	ret.a = new ILRetArray<double>(ILMemoryPool.Pool.New<double>(foundIdx), foundIdx, 1);
1210	unsafe {
1211	fixed (double* pIndices = indices, pRows = ret.GetArrayForWrite()) {
1212	double* pI = (limit >= 0) ?
1213	pIndices : (pIndices + indices.Length - foundIdx);
1214	double* pLastIndex = pI + foundIdx;
1215	double* pR = pRows;
1216	while (pI < pLastIndex) {
1217	pR++ = pI++;
1218	}
1219	}
1220	}
1221	} else {
1222	ret.a = new ILRetArray<double>(indices, foundIdx, 1);
1223	}
1224	#endregion RETURN INDICES ONLY
1225	}
1226	return ret;
1227	}
1228	}
1229
1230	#endregion HYCALPER AUTO GENERATED CODE
1231
1232	#region logicals
1233	/// <summary>
1234	/// Find nonzero elements in A
1235	/// </summary>
1236	/// <param name="A">Input array</param>
1237	/// <param name="limit">Number of elements to search for. If this value is <![CDATA[< 0]]> the function
1238	/// will return at most 'limit' nonzero elements from the end of the array ordered by ascending index.
1239	/// Set to 0 to search full array (default).</param>
1240	/// <param name="C">If not null, the function will return the row indices of nonzero elements
1241	/// as main return value. C will therefore hold the column indices of those elements. If A
1242	/// has more than 2 dimensions, the column indices will go along the 2nd dimension.</param>
1243	/// <param name="V">If not null on entrance, V will hold a copy of the values of nonzero elements returned.</param>
1244	/// <returns>Vector containing (sequential) indices of nonzero elements in A. If C was
1245	/// not null, return value will contain row indices of nonzero elements. </returns>
1246	/// <remarks>The return type of the index vectors is always 'double'. The return type
1247	/// of the element vector 'V' depends on the type of input array A. V and C may be null on
1248	/// entrance, indicating their information is not needed. If V is not null (e.g. 'empty()') C must be
1249	/// not null also. Any initial data of V or C will be lost.</remarks>
1250	public static ILRetArray<double> find(ILInLogical A, int limit,
1251	ILOutArray<double> C, ILOutLogical V) {
1252	using (ILScope.Enter(A)) {
1253	if (isnullorempty(A)) {
1254	if (!isnull(V)) {
1255	V.a = new ILLogical(ILSize.Empty00);
1256	}
1257	return empty();
1258	}
1259	ILArray<byte> tmpA = new ILArray<byte>(A.Storage);
1260	ILArray<byte> tmpV = null;
1261	if (!isnull(V)) {
1262	tmpV = new ILArray<byte>(V.Storage);
1263	}
1264	ILArray<double> ret = find(tmpA, limit, C, tmpV);
1265	if (!isnull(tmpV)) {
1266	V.a = new ILLogical(new ILLogicalStorage( tmpV.Storage.GetDataArray(), tmpV.S));
1267	}
1268	return ret;
1269	}
1270	}
1271
1272	#endregion
1273
1274	}
1275	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Update cookies preferences