Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/any.cs @ 11194

Visit:

Last change on this file since 11194 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 38.2 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	namespace ILNumerics {
48	public partial class ILMath {
49
50
51
52
53
54	#region HYCALPER AUTO GENERATED CODE
55
56	/// <summary>Determine, if any elements are nonzero</summary>
57	/// <param name="A">Input array</param>
58	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
59	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
60	public static ILRetLogical any (ILInArray<double> A, int dim = -1) {
61	using (ILScope.Enter(A)) {
62	if (dim < 0)
63	dim = A.Size.WorkingDimension();
64	if (dim >= A.Size.NumberOfDimensions)
65	throw new ILArgumentException("dimension parameter out of range!");
66	if (A.IsEmpty)
67	return new ILRetLogical(A.Size);
68	if (A.IsScalar) {
69	return new ILRetLogical (new byte [1]{(A.GetValue(0) == 0.0 \|\| double.IsNaN(A.GetValue(0)))?(byte)0:(byte)1},1,1);
70	}
71	ILSize inDim = A.Size;
72	int[] newDims = inDim.ToIntArray();
73	int tmpCount = 0;
74
75	int newLength;
76
77	byte[] retArr;
78	// build ILSize
79	newLength = inDim.NumberOfElements / newDims[dim];
80	newDims[dim] = 1;
81	retArr = ILMemoryPool.Pool.New< byte>(newLength);
82	ILSize newDimension = new ILSize(newDims);
83	int incOut = newDimension.SequentialIndexDistance(dim);
84	int dimLen = inDim[dim];
85	int nrHigherDims = inDim.NumberOfElements / dimLen;
86	if (dim == 0) {
87	#region physical along 1st leading dimension
88	unsafe {
89	fixed ( byte* pOutArr = retArr)
90	fixed ( double* pInArr = A.GetArrayForRead()) {
91
92	double* lastElement;
93
94	byte* tmpOut = pOutArr;
95
96	double* tmpIn = pInArr;
97	for (int h = nrHigherDims; h-- > 0; ) {
98	lastElement = tmpIn + dimLen;
99
100	while (tmpIn < lastElement) {
101
102	double inVal = *(tmpIn++);
103	if (double.IsNaN(inVal)) continue;
104
105	tmpCount += ( /dummy/ (inVal) == 0.0)?0:1;
106	}
107	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
108	tmpOut++;
109	}
110	}
111	}
112	#endregion
113	} else {
114	#region physical along abitrary dimension
115	// sum along abitrary dimension
116	unsafe {
117	fixed ( byte* pOutArr = retArr)
118	fixed ( double* pInArr = A.GetArrayForRead()) {
119
120	byte* lastElementOut = newLength + pOutArr - 1;
121	int inLength = inDim.NumberOfElements - 1;
122
123	double* lastElementIn = pInArr + inLength;
124	int inc = inDim.SequentialIndexDistance(dim);
125
126	byte* tmpOut = pOutArr;
127	int outLength = newLength - 1;
128
129	double* leadEnd;
130
131	double* tmpIn = pInArr;
132	for (int h = nrHigherDims; h-- > 0; ) {
133	leadEnd = tmpIn + dimLen * inc;
134
135	while (tmpIn < leadEnd) {
136
137	double inVal = *(tmpIn);
138	tmpIn += inc;
139	if (double.IsNaN(inVal)) continue;
140
141	tmpCount += ( /dummy/ (inVal) == 0.0)?0:1; //
142	}
143	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
144	tmpOut += inc;
145	if (tmpOut > lastElementOut)
146	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
147	if (tmpIn > lastElementIn)
148	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
149	}
150	}
151	}
152	#endregion
153	}
154	return new ILRetLogical(retArr, newDims);
155	}
156	}
157	/// <summary>Determine, if any elements are nonzero</summary>
158	/// <param name="A">Input array</param>
159	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
160	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
161	public static ILRetLogical any (ILInArray<Int64> A, int dim = -1) {
162	using (ILScope.Enter(A)) {
163	if (dim < 0)
164	dim = A.Size.WorkingDimension();
165	if (dim >= A.Size.NumberOfDimensions)
166	throw new ILArgumentException("dimension parameter out of range!");
167	if (A.IsEmpty)
168	return new ILRetLogical(A.Size);
169	if (A.IsScalar) {
170	return new ILRetLogical (new byte [1]{(A.GetValue(0) == 0)?(byte)0:(byte)1},1,1);
171	}
172	ILSize inDim = A.Size;
173	int[] newDims = inDim.ToIntArray();
174	int tmpCount = 0;
175
176	int newLength;
177
178	byte[] retArr;
179	// build ILSize
180	newLength = inDim.NumberOfElements / newDims[dim];
181	newDims[dim] = 1;
182	retArr = ILMemoryPool.Pool.New< byte>(newLength);
183	ILSize newDimension = new ILSize(newDims);
184	int incOut = newDimension.SequentialIndexDistance(dim);
185	int dimLen = inDim[dim];
186	int nrHigherDims = inDim.NumberOfElements / dimLen;
187	if (dim == 0) {
188	#region physical along 1st leading dimension
189	unsafe {
190	fixed ( byte* pOutArr = retArr)
191	fixed ( Int64* pInArr = A.GetArrayForRead()) {
192
193	Int64* lastElement;
194
195	byte* tmpOut = pOutArr;
196
197	Int64* tmpIn = pInArr;
198	for (int h = nrHigherDims; h-- > 0; ) {
199	lastElement = tmpIn + dimLen;
200
201	while (tmpIn < lastElement) {
202
203	Int64 inVal = *(tmpIn++);
204
205
206	tmpCount += ( /dummy/ (inVal) == 0)?0:1;
207	}
208	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
209	tmpOut++;
210	}
211	}
212	}
213	#endregion
214	} else {
215	#region physical along abitrary dimension
216	// sum along abitrary dimension
217	unsafe {
218	fixed ( byte* pOutArr = retArr)
219	fixed ( Int64* pInArr = A.GetArrayForRead()) {
220
221	byte* lastElementOut = newLength + pOutArr - 1;
222	int inLength = inDim.NumberOfElements - 1;
223
224	Int64* lastElementIn = pInArr + inLength;
225	int inc = inDim.SequentialIndexDistance(dim);
226
227	byte* tmpOut = pOutArr;
228	int outLength = newLength - 1;
229
230	Int64* leadEnd;
231
232	Int64* tmpIn = pInArr;
233	for (int h = nrHigherDims; h-- > 0; ) {
234	leadEnd = tmpIn + dimLen * inc;
235
236	while (tmpIn < leadEnd) {
237
238	Int64 inVal = *(tmpIn);
239	tmpIn += inc;
240
241
242	tmpCount += ( /dummy/ (inVal) == 0)?0:1; //
243	}
244	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
245	tmpOut += inc;
246	if (tmpOut > lastElementOut)
247	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
248	if (tmpIn > lastElementIn)
249	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
250	}
251	}
252	}
253	#endregion
254	}
255	return new ILRetLogical(retArr, newDims);
256	}
257	}
258	/// <summary>Determine, if any elements are nonzero</summary>
259	/// <param name="A">Input array</param>
260	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
261	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
262	public static ILRetLogical any (ILInArray<Int32> A, int dim = -1) {
263	using (ILScope.Enter(A)) {
264	if (dim < 0)
265	dim = A.Size.WorkingDimension();
266	if (dim >= A.Size.NumberOfDimensions)
267	throw new ILArgumentException("dimension parameter out of range!");
268	if (A.IsEmpty)
269	return new ILRetLogical(A.Size);
270	if (A.IsScalar) {
271	return new ILRetLogical (new byte [1]{(A.GetValue(0) == 0)?(byte)0:(byte)1},1,1);
272	}
273	ILSize inDim = A.Size;
274	int[] newDims = inDim.ToIntArray();
275	int tmpCount = 0;
276
277	int newLength;
278
279	byte[] retArr;
280	// build ILSize
281	newLength = inDim.NumberOfElements / newDims[dim];
282	newDims[dim] = 1;
283	retArr = ILMemoryPool.Pool.New< byte>(newLength);
284	ILSize newDimension = new ILSize(newDims);
285	int incOut = newDimension.SequentialIndexDistance(dim);
286	int dimLen = inDim[dim];
287	int nrHigherDims = inDim.NumberOfElements / dimLen;
288	if (dim == 0) {
289	#region physical along 1st leading dimension
290	unsafe {
291	fixed ( byte* pOutArr = retArr)
292	fixed ( Int32* pInArr = A.GetArrayForRead()) {
293
294	Int32* lastElement;
295
296	byte* tmpOut = pOutArr;
297
298	Int32* tmpIn = pInArr;
299	for (int h = nrHigherDims; h-- > 0; ) {
300	lastElement = tmpIn + dimLen;
301
302	while (tmpIn < lastElement) {
303
304	Int32 inVal = *(tmpIn++);
305
306
307	tmpCount += ( /dummy/ (inVal) == 0)?0:1;
308	}
309	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
310	tmpOut++;
311	}
312	}
313	}
314	#endregion
315	} else {
316	#region physical along abitrary dimension
317	// sum along abitrary dimension
318	unsafe {
319	fixed ( byte* pOutArr = retArr)
320	fixed ( Int32* pInArr = A.GetArrayForRead()) {
321
322	byte* lastElementOut = newLength + pOutArr - 1;
323	int inLength = inDim.NumberOfElements - 1;
324
325	Int32* lastElementIn = pInArr + inLength;
326	int inc = inDim.SequentialIndexDistance(dim);
327
328	byte* tmpOut = pOutArr;
329	int outLength = newLength - 1;
330
331	Int32* leadEnd;
332
333	Int32* tmpIn = pInArr;
334	for (int h = nrHigherDims; h-- > 0; ) {
335	leadEnd = tmpIn + dimLen * inc;
336
337	while (tmpIn < leadEnd) {
338
339	Int32 inVal = *(tmpIn);
340	tmpIn += inc;
341
342
343	tmpCount += ( /dummy/ (inVal) == 0)?0:1; //
344	}
345	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
346	tmpOut += inc;
347	if (tmpOut > lastElementOut)
348	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
349	if (tmpIn > lastElementIn)
350	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
351	}
352	}
353	}
354	#endregion
355	}
356	return new ILRetLogical(retArr, newDims);
357	}
358	}
359	/// <summary>Determine, if any elements are nonzero</summary>
360	/// <param name="A">Input array</param>
361	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
362	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
363	public static ILRetLogical any (ILInArray<byte> A, int dim = -1) {
364	using (ILScope.Enter(A)) {
365	if (dim < 0)
366	dim = A.Size.WorkingDimension();
367	if (dim >= A.Size.NumberOfDimensions)
368	throw new ILArgumentException("dimension parameter out of range!");
369	if (A.IsEmpty)
370	return new ILRetLogical(A.Size);
371	if (A.IsScalar) {
372	return new ILRetLogical (new byte [1]{(A.GetValue(0) == 0)?(byte)0:(byte)1},1,1);
373	}
374	ILSize inDim = A.Size;
375	int[] newDims = inDim.ToIntArray();
376	int tmpCount = 0;
377
378	int newLength;
379
380	byte[] retArr;
381	// build ILSize
382	newLength = inDim.NumberOfElements / newDims[dim];
383	newDims[dim] = 1;
384	retArr = ILMemoryPool.Pool.New< byte>(newLength);
385	ILSize newDimension = new ILSize(newDims);
386	int incOut = newDimension.SequentialIndexDistance(dim);
387	int dimLen = inDim[dim];
388	int nrHigherDims = inDim.NumberOfElements / dimLen;
389	if (dim == 0) {
390	#region physical along 1st leading dimension
391	unsafe {
392	fixed ( byte* pOutArr = retArr)
393	fixed ( byte* pInArr = A.GetArrayForRead()) {
394
395	byte* lastElement;
396
397	byte* tmpOut = pOutArr;
398
399	byte* tmpIn = pInArr;
400	for (int h = nrHigherDims; h-- > 0; ) {
401	lastElement = tmpIn + dimLen;
402
403	while (tmpIn < lastElement) {
404
405	byte inVal = *(tmpIn++);
406
407
408	tmpCount += ( /dummy/ (inVal) == 0)?0:1;
409	}
410	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
411	tmpOut++;
412	}
413	}
414	}
415	#endregion
416	} else {
417	#region physical along abitrary dimension
418	// sum along abitrary dimension
419	unsafe {
420	fixed ( byte* pOutArr = retArr)
421	fixed ( byte* pInArr = A.GetArrayForRead()) {
422
423	byte* lastElementOut = newLength + pOutArr - 1;
424	int inLength = inDim.NumberOfElements - 1;
425
426	byte* lastElementIn = pInArr + inLength;
427	int inc = inDim.SequentialIndexDistance(dim);
428
429	byte* tmpOut = pOutArr;
430	int outLength = newLength - 1;
431
432	byte* leadEnd;
433
434	byte* tmpIn = pInArr;
435	for (int h = nrHigherDims; h-- > 0; ) {
436	leadEnd = tmpIn + dimLen * inc;
437
438	while (tmpIn < leadEnd) {
439
440	byte inVal = *(tmpIn);
441	tmpIn += inc;
442
443
444	tmpCount += ( /dummy/ (inVal) == 0)?0:1; //
445	}
446	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
447	tmpOut += inc;
448	if (tmpOut > lastElementOut)
449	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
450	if (tmpIn > lastElementIn)
451	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
452	}
453	}
454	}
455	#endregion
456	}
457	return new ILRetLogical(retArr, newDims);
458	}
459	}
460	/// <summary>Determine, if any elements are nonzero</summary>
461	/// <param name="A">Input array</param>
462	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
463	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
464	public static ILRetLogical any (ILInArray<fcomplex> A, int dim = -1) {
465	using (ILScope.Enter(A)) {
466	if (dim < 0)
467	dim = A.Size.WorkingDimension();
468	if (dim >= A.Size.NumberOfDimensions)
469	throw new ILArgumentException("dimension parameter out of range!");
470	if (A.IsEmpty)
471	return new ILRetLogical(A.Size);
472	if (A.IsScalar) {
473	return new ILRetLogical (new byte [1]{(A.GetValue(0).iszero() \|\| fcomplex.IsNaN(A.GetValue(0)))?(byte)1:(byte)0},1,1);
474	}
475	ILSize inDim = A.Size;
476	int[] newDims = inDim.ToIntArray();
477	int tmpCount = 0;
478
479	int newLength;
480
481	byte[] retArr;
482	// build ILSize
483	newLength = inDim.NumberOfElements / newDims[dim];
484	newDims[dim] = 1;
485	retArr = ILMemoryPool.Pool.New< byte>(newLength);
486	ILSize newDimension = new ILSize(newDims);
487	int incOut = newDimension.SequentialIndexDistance(dim);
488	int dimLen = inDim[dim];
489	int nrHigherDims = inDim.NumberOfElements / dimLen;
490	if (dim == 0) {
491	#region physical along 1st leading dimension
492	unsafe {
493	fixed ( byte* pOutArr = retArr)
494	fixed ( fcomplex* pInArr = A.GetArrayForRead()) {
495
496	fcomplex* lastElement;
497
498	byte* tmpOut = pOutArr;
499
500	fcomplex* tmpIn = pInArr;
501	for (int h = nrHigherDims; h-- > 0; ) {
502	lastElement = tmpIn + dimLen;
503
504	while (tmpIn < lastElement) {
505
506	fcomplex inVal = *(tmpIn++);
507	if (fcomplex.IsNaN(inVal)) continue;
508
509	tmpCount += ( /dummy/ (inVal) .iszero())?0:1;
510	}
511	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
512	tmpOut++;
513	}
514	}
515	}
516	#endregion
517	} else {
518	#region physical along abitrary dimension
519	// sum along abitrary dimension
520	unsafe {
521	fixed ( byte* pOutArr = retArr)
522	fixed ( fcomplex* pInArr = A.GetArrayForRead()) {
523
524	byte* lastElementOut = newLength + pOutArr - 1;
525	int inLength = inDim.NumberOfElements - 1;
526
527	fcomplex* lastElementIn = pInArr + inLength;
528	int inc = inDim.SequentialIndexDistance(dim);
529
530	byte* tmpOut = pOutArr;
531	int outLength = newLength - 1;
532
533	fcomplex* leadEnd;
534
535	fcomplex* tmpIn = pInArr;
536	for (int h = nrHigherDims; h-- > 0; ) {
537	leadEnd = tmpIn + dimLen * inc;
538
539	while (tmpIn < leadEnd) {
540
541	fcomplex inVal = *(tmpIn);
542	tmpIn += inc;
543	if (fcomplex.IsNaN(inVal)) continue;
544
545	tmpCount += ( /dummy/ (inVal) .iszero())?0:1; //
546	}
547	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
548	tmpOut += inc;
549	if (tmpOut > lastElementOut)
550	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
551	if (tmpIn > lastElementIn)
552	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
553	}
554	}
555	}
556	#endregion
557	}
558	return new ILRetLogical(retArr, newDims);
559	}
560	}
561	/// <summary>Determine, if any elements are nonzero</summary>
562	/// <param name="A">Input array</param>
563	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
564	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
565	public static ILRetLogical any (ILInArray<float> A, int dim = -1) {
566	using (ILScope.Enter(A)) {
567	if (dim < 0)
568	dim = A.Size.WorkingDimension();
569	if (dim >= A.Size.NumberOfDimensions)
570	throw new ILArgumentException("dimension parameter out of range!");
571	if (A.IsEmpty)
572	return new ILRetLogical(A.Size);
573	if (A.IsScalar) {
574	return new ILRetLogical (new byte [1]{(A.GetValue(0) == 0.0f \|\| float.IsNaN(A.GetValue(0)))?(byte)0:(byte)1},1,1);
575	}
576	ILSize inDim = A.Size;
577	int[] newDims = inDim.ToIntArray();
578	int tmpCount = 0;
579
580	int newLength;
581
582	byte[] retArr;
583	// build ILSize
584	newLength = inDim.NumberOfElements / newDims[dim];
585	newDims[dim] = 1;
586	retArr = ILMemoryPool.Pool.New< byte>(newLength);
587	ILSize newDimension = new ILSize(newDims);
588	int incOut = newDimension.SequentialIndexDistance(dim);
589	int dimLen = inDim[dim];
590	int nrHigherDims = inDim.NumberOfElements / dimLen;
591	if (dim == 0) {
592	#region physical along 1st leading dimension
593	unsafe {
594	fixed ( byte* pOutArr = retArr)
595	fixed ( float* pInArr = A.GetArrayForRead()) {
596
597	float* lastElement;
598
599	byte* tmpOut = pOutArr;
600
601	float* tmpIn = pInArr;
602	for (int h = nrHigherDims; h-- > 0; ) {
603	lastElement = tmpIn + dimLen;
604
605	while (tmpIn < lastElement) {
606
607	float inVal = *(tmpIn++);
608	if (float.IsNaN(inVal)) continue;
609
610	tmpCount += ( /dummy/ (inVal) == 0.0f)?0:1;
611	}
612	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
613	tmpOut++;
614	}
615	}
616	}
617	#endregion
618	} else {
619	#region physical along abitrary dimension
620	// sum along abitrary dimension
621	unsafe {
622	fixed ( byte* pOutArr = retArr)
623	fixed ( float* pInArr = A.GetArrayForRead()) {
624
625	byte* lastElementOut = newLength + pOutArr - 1;
626	int inLength = inDim.NumberOfElements - 1;
627
628	float* lastElementIn = pInArr + inLength;
629	int inc = inDim.SequentialIndexDistance(dim);
630
631	byte* tmpOut = pOutArr;
632	int outLength = newLength - 1;
633
634	float* leadEnd;
635
636	float* tmpIn = pInArr;
637	for (int h = nrHigherDims; h-- > 0; ) {
638	leadEnd = tmpIn + dimLen * inc;
639
640	while (tmpIn < leadEnd) {
641
642	float inVal = *(tmpIn);
643	tmpIn += inc;
644	if (float.IsNaN(inVal)) continue;
645
646	tmpCount += ( /dummy/ (inVal) == 0.0f)?0:1; //
647	}
648	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
649	tmpOut += inc;
650	if (tmpOut > lastElementOut)
651	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
652	if (tmpIn > lastElementIn)
653	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
654	}
655	}
656	}
657	#endregion
658	}
659	return new ILRetLogical(retArr, newDims);
660	}
661	}
662	/// <summary>Determine, if any elements are nonzero</summary>
663	/// <param name="A">Input array</param>
664	/// <param name="dim">[Optional] Index of the dimension to operate along. If omitted operates along the first non singleton dimension (i.e. != 1).</param>
665	/// <returns><para>Array of same size as A, having the specified or first non-singleton dimension reduced to 1, if any elements along that dimension are non-zero, '0' else. </para></returns>
666	public static ILRetLogical any (ILInArray<complex> A, int dim = -1) {
667	using (ILScope.Enter(A)) {
668	if (dim < 0)
669	dim = A.Size.WorkingDimension();
670	if (dim >= A.Size.NumberOfDimensions)
671	throw new ILArgumentException("dimension parameter out of range!");
672	if (A.IsEmpty)
673	return new ILRetLogical(A.Size);
674	if (A.IsScalar) {
675	return new ILRetLogical (new byte [1]{(A.GetValue(0).iszero() \|\| complex.IsNaN(A.GetValue(0)))?(byte)0:(byte)1},1,1);
676	}
677	ILSize inDim = A.Size;
678	int[] newDims = inDim.ToIntArray();
679	int tmpCount = 0;
680
681	int newLength;
682
683	byte[] retArr;
684	// build ILSize
685	newLength = inDim.NumberOfElements / newDims[dim];
686	newDims[dim] = 1;
687	retArr = ILMemoryPool.Pool.New< byte>(newLength);
688	ILSize newDimension = new ILSize(newDims);
689	int incOut = newDimension.SequentialIndexDistance(dim);
690	int dimLen = inDim[dim];
691	int nrHigherDims = inDim.NumberOfElements / dimLen;
692	if (dim == 0) {
693	#region physical along 1st leading dimension
694	unsafe {
695	fixed ( byte* pOutArr = retArr)
696	fixed ( complex* pInArr = A.GetArrayForRead()) {
697
698	complex* lastElement;
699
700	byte* tmpOut = pOutArr;
701
702	complex* tmpIn = pInArr;
703	for (int h = nrHigherDims; h-- > 0; ) {
704	lastElement = tmpIn + dimLen;
705
706	while (tmpIn < lastElement) {
707
708	complex inVal = *(tmpIn++);
709	if (complex.IsNaN(inVal)) continue;
710
711	tmpCount += ( /dummy/ (inVal) .iszero())?0:1;
712	}
713	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
714	tmpOut++;
715	}
716	}
717	}
718	#endregion
719	} else {
720	#region physical along abitrary dimension
721	// sum along abitrary dimension
722	unsafe {
723	fixed ( byte* pOutArr = retArr)
724	fixed ( complex* pInArr = A.GetArrayForRead()) {
725
726	byte* lastElementOut = newLength + pOutArr - 1;
727	int inLength = inDim.NumberOfElements - 1;
728
729	complex* lastElementIn = pInArr + inLength;
730	int inc = inDim.SequentialIndexDistance(dim);
731
732	byte* tmpOut = pOutArr;
733	int outLength = newLength - 1;
734
735	complex* leadEnd;
736
737	complex* tmpIn = pInArr;
738	for (int h = nrHigherDims; h-- > 0; ) {
739	leadEnd = tmpIn + dimLen * inc;
740
741	while (tmpIn < leadEnd) {
742
743	complex inVal = *(tmpIn);
744	tmpIn += inc;
745	if (complex.IsNaN(inVal)) continue;
746
747	tmpCount += ( /dummy/ (inVal) .iszero())?0:1; //
748	}
749	*tmpOut = (tmpCount == 0)? (byte)0:(byte)1; tmpCount = 0;
750	tmpOut += inc;
751	if (tmpOut > lastElementOut)
752	tmpOut = pOutArr + ((tmpOut - pOutArr) - outLength);
753	if (tmpIn > lastElementIn)
754	tmpIn = pInArr + ((tmpIn - pInArr) - inLength);
755	}
756	}
757	}
758	#endregion
759	}
760	return new ILRetLogical(retArr, newDims);
761	}
762	}
763
764	#endregion HYCALPER AUTO GENERATED CODE
765	}
766	}

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

Download in other formats:

Update cookies preferences