Context Navigation

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

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

Download in other formats:

Update cookies preferences