Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/eq.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: 98.6 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
41
42	using System;
43	using System.Collections.Generic;
44	using System.Text;
45	using System.Runtime.InteropServices;
46	using ILNumerics.Storage;
47	using ILNumerics.Misc;
48	using ILNumerics.Native;
49	using ILNumerics.Exceptions;
50
51	namespace ILNumerics {
52
53	public partial class ILMath {
54
55
56	/// <summary>Elementwise logical 'equal' operator</summary>
57	/// <param name="A">Input array A</param>
58	/// <param name="B">Input array B</param>
59	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
60	/// <remarks><para>On empty input an empty array will be returned.</para>
61	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
62	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
63	public unsafe static ILRetLogical eq(ILInArray<double> A, ILInArray<double> B) {
64	using (ILScope.Enter(A, B)) {
65	int outLen;
66	BinOpItMode mode;
67	byte[] retArr;
68
69	double[] arrA = A.GetArrayForRead();
70
71	double[] arrB = B.GetArrayForRead();
72	ILSize outDims;
73	if (A.IsScalar) {
74	if (B.IsScalar) {
75
76	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
77	} else if (B.IsEmpty) {
78	return new ILRetLogical(B.Size);
79	} else {
80	outLen = B.S.NumberOfElements;
81	retArr = ILMemoryPool.Pool.New<byte>(outLen);
82	mode = BinOpItMode.SAN;
83	}
84	outDims = B.Size;
85	} else {
86	outDims = A.Size;
87	if (B.IsScalar) {
88	if (A.IsEmpty) {
89	return new ILRetLogical(A.Size);
90	}
91	outLen = A.S.NumberOfElements;
92	retArr = ILMemoryPool.Pool.New<byte>(outLen);
93	mode = BinOpItMode.ASN;
94	} else {
95	// array + array
96	if (!A.Size.IsSameSize(B.Size)) {
97	return eqEx(A,B);
98	}
99	outLen = A.S.NumberOfElements;
100	retArr = ILMemoryPool.Pool.New<byte>(outLen);
101	mode = BinOpItMode.AAN;
102	}
103	}
104	int workerCount = 1;
105	Action<object> worker = data => {
106	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
107	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
108	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
109	double scalar;
110	cLast = cp + range.Item2;
111	#region loops
112	switch (mode) {
113	case BinOpItMode.AAN:
114	double* ap = ((double*)range.Item3 + range.Item1);
115	double* bp = ((double*)range.Item4 + range.Item1);
116	while (cp < cLast) {
117
118	cp = (ap == *bp) ? (byte)1 : (byte)0;
119	cp++;
120	ap++;
121	bp++;
122	}
123	break;
124	case BinOpItMode.ASN:
125	ap = ((double*)range.Item3 + range.Item1);
126	scalar = ((double)range.Item4);
127	while (cp < cLast) {
128
129	cp = (ap == scalar) ? (byte)1 : (byte)0;
130	cp++;
131	ap++;
132
133	}
134	break;
135	case BinOpItMode.SAN:
136	scalar = ((double)range.Item3);
137	bp = ((double*)range.Item4 + range.Item1);
138	while (cp < cLast) {
139
140	cp = (scalar == bp) ? (byte)1 : (byte)0;
141	cp++;
142	bp++;
143	}
144	break;
145	default:
146	break;
147	}
148	#endregion
149	System.Threading.Interlocked.Decrement(ref workerCount);
150	};
151
152	#region do the work
153	fixed (double* arrAP = arrA)
154	fixed (double* arrBP = arrB)
155	fixed (byte* retArrP = retArr) {
156	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
157	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
158	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
159	workItemLength = outLen / workItemCount;
160	} else {
161	workItemLength = outLen / 2;
162	workItemCount = 2;
163	}
164	} else {
165	workItemLength = outLen;
166	workItemCount = 1;
167	}
168
169	for (; i < workItemCount - 1; i++) {
170	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
171	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
172	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
173	System.Threading.Interlocked.Increment(ref workerCount);
174	ILThreadPool.QueueUserWorkItem(i, worker, range);
175	}
176	// the last (or may the only) chunk is done right here
177	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
178	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
179	ILThreadPool.Wait4Workers(ref workerCount);
180	}
181
182	#endregion
183	return new ILRetLogical(retArr, outDims);
184	}
185	}
186
187	private static unsafe ILRetLogical eqEx(ILInArray<double> A, ILInArray<double> B) {
188	using (ILScope.Enter(A, B)) {
189	#region parameter checking
190	if (isnull(A) \|\| isnull(B))
191	return new ILRetLogical(ILSize.Empty00);
192	if (A.IsEmpty) {
193	return new ILRetLogical(B.S);
194	} else if (B.IsEmpty) {
195	return new ILRetLogical(A.S);
196	}
197	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
198	// return add(A,B);
199	int dim = -1;
200	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
201	if (A.S[l] != B.S[l]) {
202	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
203	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
204	}
205	dim = l;
206	}
207	}
208	if (dim > 1)
209	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
210	#endregion
211
212	#region parameter preparation
213	byte[] retArr;
214
215	double[] arrA = A.GetArrayForRead();
216
217	double[] arrB = B.GetArrayForRead();
218	ILSize outDims;
219	BinOptItExMode mode;
220	int arrInc = 0;
221	int arrStepInc = 0;
222	int dimLen = 0;
223	if (A.IsVector) {
224	outDims = B.S;
225	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
226	mode = BinOptItExMode.VAN;
227	dimLen = A.Length;
228	} else if (B.IsVector) {
229	outDims = A.S;
230	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
231	mode = BinOptItExMode.AVN;
232	dimLen = B.Length;
233	} else {
234	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
235	}
236	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
237	arrStepInc = outDims.SequentialIndexDistance(dim);
238	#endregion
239
240	#region worker loops definition
241	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
242	int workerCount = 1;
243	Action<object> worker = data => {
244	// expects: iStart, iLen, ap, bp, cp
245	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
246	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
247
248	double* ap;
249
250	double* bp;
251	byte* cp;
252	switch (mode) {
253	case BinOptItExMode.VAN:
254	for (int s = 0; s < range.Item2; s++) {
255	ap = (double*)range.Item3;
256	bp = (double)range.Item4 + range.Item1 + s arrStepInc; ;
257	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
258	for (int l = 0; l < dimLen; l++) {
259
260	cp = (ap == *bp) ? (byte)1 : (byte)0;
261	ap++;
262	bp += arrInc;
263	cp += arrInc;
264	}
265	}
266	break;
267	case BinOptItExMode.AVN:
268	for (int s = 0; s < range.Item2; s++) {
269	ap = (double)range.Item3 + range.Item1 + s arrStepInc;
270	bp = (double*)range.Item4;
271	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
272	for (int l = 0; l < dimLen; l++) {
273
274	cp = (ap == *bp) ? (byte)1 : (byte)0;
275	ap += arrInc;
276	bp++;
277	cp += arrInc;
278	}
279	}
280	break;
281	}
282	System.Threading.Interlocked.Decrement(ref workerCount);
283	};
284	#endregion
285
286	#region work distribution
287	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
288	int outLen = outDims.NumberOfElements;
289	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
290	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
291	workItemLength = outLen / dimLen / workItemCount;
292	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
293	} else {
294	workItemLength = outLen / dimLen / 2;
295	workItemCount = 2;
296	}
297	} else {
298	workItemLength = outLen / dimLen;
299	workItemCount = 1;
300	}
301
302	fixed ( double* arrAP = arrA)
303	fixed ( double* arrBP = arrB)
304	fixed (byte* retArrP = retArr) {
305
306	for (; i < workItemCount - 1; i++) {
307	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
308	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
309	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
310	System.Threading.Interlocked.Increment(ref workerCount);
311	ILThreadPool.QueueUserWorkItem(i, worker, range);
312	}
313	// the last (or may the only) chunk is done right here
314	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
315	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
316	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
317
318	ILThreadPool.Wait4Workers(ref workerCount);
319	}
320	#endregion
321
322	return new ILRetLogical(retStorage);
323	}
324	}
325
326
327	#region HYCALPER AUTO GENERATED CODE
328
329	/// <summary>Elementwise logical 'equal' operator</summary>
330	/// <param name="A">Input array A</param>
331	/// <param name="B">Input array B</param>
332	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
333	/// <remarks><para>On empty input an empty array will be returned.</para>
334	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
335	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
336	public unsafe static ILRetLogical eq(ILInArray<Int64> A, ILInArray<Int64> B) {
337	using (ILScope.Enter(A, B)) {
338	int outLen;
339	BinOpItMode mode;
340	byte[] retArr;
341
342	Int64[] arrA = A.GetArrayForRead();
343
344	Int64[] arrB = B.GetArrayForRead();
345	ILSize outDims;
346	if (A.IsScalar) {
347	if (B.IsScalar) {
348
349	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
350	} else if (B.IsEmpty) {
351	return new ILRetLogical(B.Size);
352	} else {
353	outLen = B.S.NumberOfElements;
354	retArr = ILMemoryPool.Pool.New<byte>(outLen);
355	mode = BinOpItMode.SAN;
356	}
357	outDims = B.Size;
358	} else {
359	outDims = A.Size;
360	if (B.IsScalar) {
361	if (A.IsEmpty) {
362	return new ILRetLogical(A.Size);
363	}
364	outLen = A.S.NumberOfElements;
365	retArr = ILMemoryPool.Pool.New<byte>(outLen);
366	mode = BinOpItMode.ASN;
367	} else {
368	// array + array
369	if (!A.Size.IsSameSize(B.Size)) {
370	return eqEx(A,B);
371	}
372	outLen = A.S.NumberOfElements;
373	retArr = ILMemoryPool.Pool.New<byte>(outLen);
374	mode = BinOpItMode.AAN;
375	}
376	}
377	int workerCount = 1;
378	Action<object> worker = data => {
379	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
380	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
381	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
382	Int64 scalar;
383	cLast = cp + range.Item2;
384	#region loops
385	switch (mode) {
386	case BinOpItMode.AAN:
387	Int64* ap = ((Int64*)range.Item3 + range.Item1);
388	Int64* bp = ((Int64*)range.Item4 + range.Item1);
389	while (cp < cLast) {
390
391	cp = (ap == *bp) ? (byte)1 : (byte)0;
392	cp++;
393	ap++;
394	bp++;
395	}
396	break;
397	case BinOpItMode.ASN:
398	ap = ((Int64*)range.Item3 + range.Item1);
399	scalar = ((Int64)range.Item4);
400	while (cp < cLast) {
401
402	cp = (ap == scalar) ? (byte)1 : (byte)0;
403	cp++;
404	ap++;
405
406	}
407	break;
408	case BinOpItMode.SAN:
409	scalar = ((Int64)range.Item3);
410	bp = ((Int64*)range.Item4 + range.Item1);
411	while (cp < cLast) {
412
413	cp = (scalar == bp) ? (byte)1 : (byte)0;
414	cp++;
415	bp++;
416	}
417	break;
418	default:
419	break;
420	}
421	#endregion
422	System.Threading.Interlocked.Decrement(ref workerCount);
423	};
424
425	#region do the work
426	fixed (Int64* arrAP = arrA)
427	fixed (Int64* arrBP = arrB)
428	fixed (byte* retArrP = retArr) {
429	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
430	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
431	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
432	workItemLength = outLen / workItemCount;
433	} else {
434	workItemLength = outLen / 2;
435	workItemCount = 2;
436	}
437	} else {
438	workItemLength = outLen;
439	workItemCount = 1;
440	}
441
442	for (; i < workItemCount - 1; i++) {
443	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
444	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
445	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
446	System.Threading.Interlocked.Increment(ref workerCount);
447	ILThreadPool.QueueUserWorkItem(i, worker, range);
448	}
449	// the last (or may the only) chunk is done right here
450	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
451	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
452	ILThreadPool.Wait4Workers(ref workerCount);
453	}
454
455	#endregion
456	return new ILRetLogical(retArr, outDims);
457	}
458	}
459
460	private static unsafe ILRetLogical eqEx(ILInArray<Int64> A, ILInArray<Int64> B) {
461	using (ILScope.Enter(A, B)) {
462	#region parameter checking
463	if (isnull(A) \|\| isnull(B))
464	return new ILRetLogical(ILSize.Empty00);
465	if (A.IsEmpty) {
466	return new ILRetLogical(B.S);
467	} else if (B.IsEmpty) {
468	return new ILRetLogical(A.S);
469	}
470	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
471	// return add(A,B);
472	int dim = -1;
473	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
474	if (A.S[l] != B.S[l]) {
475	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
476	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
477	}
478	dim = l;
479	}
480	}
481	if (dim > 1)
482	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
483	#endregion
484
485	#region parameter preparation
486	byte[] retArr;
487
488	Int64[] arrA = A.GetArrayForRead();
489
490	Int64[] arrB = B.GetArrayForRead();
491	ILSize outDims;
492	BinOptItExMode mode;
493	int arrInc = 0;
494	int arrStepInc = 0;
495	int dimLen = 0;
496	if (A.IsVector) {
497	outDims = B.S;
498	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
499	mode = BinOptItExMode.VAN;
500	dimLen = A.Length;
501	} else if (B.IsVector) {
502	outDims = A.S;
503	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
504	mode = BinOptItExMode.AVN;
505	dimLen = B.Length;
506	} else {
507	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
508	}
509	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
510	arrStepInc = outDims.SequentialIndexDistance(dim);
511	#endregion
512
513	#region worker loops definition
514	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
515	int workerCount = 1;
516	Action<object> worker = data => {
517	// expects: iStart, iLen, ap, bp, cp
518	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
519	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
520
521	Int64* ap;
522
523	Int64* bp;
524	byte* cp;
525	switch (mode) {
526	case BinOptItExMode.VAN:
527	for (int s = 0; s < range.Item2; s++) {
528	ap = (Int64*)range.Item3;
529	bp = (Int64)range.Item4 + range.Item1 + s arrStepInc; ;
530	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
531	for (int l = 0; l < dimLen; l++) {
532
533	cp = (ap == *bp) ? (byte)1 : (byte)0;
534	ap++;
535	bp += arrInc;
536	cp += arrInc;
537	}
538	}
539	break;
540	case BinOptItExMode.AVN:
541	for (int s = 0; s < range.Item2; s++) {
542	ap = (Int64)range.Item3 + range.Item1 + s arrStepInc;
543	bp = (Int64*)range.Item4;
544	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
545	for (int l = 0; l < dimLen; l++) {
546
547	cp = (ap == *bp) ? (byte)1 : (byte)0;
548	ap += arrInc;
549	bp++;
550	cp += arrInc;
551	}
552	}
553	break;
554	}
555	System.Threading.Interlocked.Decrement(ref workerCount);
556	};
557	#endregion
558
559	#region work distribution
560	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
561	int outLen = outDims.NumberOfElements;
562	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
563	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
564	workItemLength = outLen / dimLen / workItemCount;
565	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
566	} else {
567	workItemLength = outLen / dimLen / 2;
568	workItemCount = 2;
569	}
570	} else {
571	workItemLength = outLen / dimLen;
572	workItemCount = 1;
573	}
574
575	fixed ( Int64* arrAP = arrA)
576	fixed ( Int64* arrBP = arrB)
577	fixed (byte* retArrP = retArr) {
578
579	for (; i < workItemCount - 1; i++) {
580	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
581	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
582	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
583	System.Threading.Interlocked.Increment(ref workerCount);
584	ILThreadPool.QueueUserWorkItem(i, worker, range);
585	}
586	// the last (or may the only) chunk is done right here
587	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
588	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
589	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
590
591	ILThreadPool.Wait4Workers(ref workerCount);
592	}
593	#endregion
594
595	return new ILRetLogical(retStorage);
596	}
597	}
598
599	/// <summary>Elementwise logical 'equal' operator</summary>
600	/// <param name="A">Input array A</param>
601	/// <param name="B">Input array B</param>
602	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
603	/// <remarks><para>On empty input an empty array will be returned.</para>
604	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
605	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
606	public unsafe static ILRetLogical eq(ILInArray<Int32> A, ILInArray<Int32> B) {
607	using (ILScope.Enter(A, B)) {
608	int outLen;
609	BinOpItMode mode;
610	byte[] retArr;
611
612	Int32[] arrA = A.GetArrayForRead();
613
614	Int32[] arrB = B.GetArrayForRead();
615	ILSize outDims;
616	if (A.IsScalar) {
617	if (B.IsScalar) {
618
619	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
620	} else if (B.IsEmpty) {
621	return new ILRetLogical(B.Size);
622	} else {
623	outLen = B.S.NumberOfElements;
624	retArr = ILMemoryPool.Pool.New<byte>(outLen);
625	mode = BinOpItMode.SAN;
626	}
627	outDims = B.Size;
628	} else {
629	outDims = A.Size;
630	if (B.IsScalar) {
631	if (A.IsEmpty) {
632	return new ILRetLogical(A.Size);
633	}
634	outLen = A.S.NumberOfElements;
635	retArr = ILMemoryPool.Pool.New<byte>(outLen);
636	mode = BinOpItMode.ASN;
637	} else {
638	// array + array
639	if (!A.Size.IsSameSize(B.Size)) {
640	return eqEx(A,B);
641	}
642	outLen = A.S.NumberOfElements;
643	retArr = ILMemoryPool.Pool.New<byte>(outLen);
644	mode = BinOpItMode.AAN;
645	}
646	}
647	int workerCount = 1;
648	Action<object> worker = data => {
649	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
650	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
651	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
652	Int32 scalar;
653	cLast = cp + range.Item2;
654	#region loops
655	switch (mode) {
656	case BinOpItMode.AAN:
657	Int32* ap = ((Int32*)range.Item3 + range.Item1);
658	Int32* bp = ((Int32*)range.Item4 + range.Item1);
659	while (cp < cLast) {
660
661	cp = (ap == *bp) ? (byte)1 : (byte)0;
662	cp++;
663	ap++;
664	bp++;
665	}
666	break;
667	case BinOpItMode.ASN:
668	ap = ((Int32*)range.Item3 + range.Item1);
669	scalar = ((Int32)range.Item4);
670	while (cp < cLast) {
671
672	cp = (ap == scalar) ? (byte)1 : (byte)0;
673	cp++;
674	ap++;
675
676	}
677	break;
678	case BinOpItMode.SAN:
679	scalar = ((Int32)range.Item3);
680	bp = ((Int32*)range.Item4 + range.Item1);
681	while (cp < cLast) {
682
683	cp = (scalar == bp) ? (byte)1 : (byte)0;
684	cp++;
685	bp++;
686	}
687	break;
688	default:
689	break;
690	}
691	#endregion
692	System.Threading.Interlocked.Decrement(ref workerCount);
693	};
694
695	#region do the work
696	fixed (Int32* arrAP = arrA)
697	fixed (Int32* arrBP = arrB)
698	fixed (byte* retArrP = retArr) {
699	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
700	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
701	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
702	workItemLength = outLen / workItemCount;
703	} else {
704	workItemLength = outLen / 2;
705	workItemCount = 2;
706	}
707	} else {
708	workItemLength = outLen;
709	workItemCount = 1;
710	}
711
712	for (; i < workItemCount - 1; i++) {
713	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
714	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
715	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
716	System.Threading.Interlocked.Increment(ref workerCount);
717	ILThreadPool.QueueUserWorkItem(i, worker, range);
718	}
719	// the last (or may the only) chunk is done right here
720	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
721	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
722	ILThreadPool.Wait4Workers(ref workerCount);
723	}
724
725	#endregion
726	return new ILRetLogical(retArr, outDims);
727	}
728	}
729
730	private static unsafe ILRetLogical eqEx(ILInArray<Int32> A, ILInArray<Int32> B) {
731	using (ILScope.Enter(A, B)) {
732	#region parameter checking
733	if (isnull(A) \|\| isnull(B))
734	return new ILRetLogical(ILSize.Empty00);
735	if (A.IsEmpty) {
736	return new ILRetLogical(B.S);
737	} else if (B.IsEmpty) {
738	return new ILRetLogical(A.S);
739	}
740	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
741	// return add(A,B);
742	int dim = -1;
743	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
744	if (A.S[l] != B.S[l]) {
745	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
746	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
747	}
748	dim = l;
749	}
750	}
751	if (dim > 1)
752	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
753	#endregion
754
755	#region parameter preparation
756	byte[] retArr;
757
758	Int32[] arrA = A.GetArrayForRead();
759
760	Int32[] arrB = B.GetArrayForRead();
761	ILSize outDims;
762	BinOptItExMode mode;
763	int arrInc = 0;
764	int arrStepInc = 0;
765	int dimLen = 0;
766	if (A.IsVector) {
767	outDims = B.S;
768	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
769	mode = BinOptItExMode.VAN;
770	dimLen = A.Length;
771	} else if (B.IsVector) {
772	outDims = A.S;
773	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
774	mode = BinOptItExMode.AVN;
775	dimLen = B.Length;
776	} else {
777	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
778	}
779	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
780	arrStepInc = outDims.SequentialIndexDistance(dim);
781	#endregion
782
783	#region worker loops definition
784	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
785	int workerCount = 1;
786	Action<object> worker = data => {
787	// expects: iStart, iLen, ap, bp, cp
788	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
789	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
790
791	Int32* ap;
792
793	Int32* bp;
794	byte* cp;
795	switch (mode) {
796	case BinOptItExMode.VAN:
797	for (int s = 0; s < range.Item2; s++) {
798	ap = (Int32*)range.Item3;
799	bp = (Int32)range.Item4 + range.Item1 + s arrStepInc; ;
800	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
801	for (int l = 0; l < dimLen; l++) {
802
803	cp = (ap == *bp) ? (byte)1 : (byte)0;
804	ap++;
805	bp += arrInc;
806	cp += arrInc;
807	}
808	}
809	break;
810	case BinOptItExMode.AVN:
811	for (int s = 0; s < range.Item2; s++) {
812	ap = (Int32)range.Item3 + range.Item1 + s arrStepInc;
813	bp = (Int32*)range.Item4;
814	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
815	for (int l = 0; l < dimLen; l++) {
816
817	cp = (ap == *bp) ? (byte)1 : (byte)0;
818	ap += arrInc;
819	bp++;
820	cp += arrInc;
821	}
822	}
823	break;
824	}
825	System.Threading.Interlocked.Decrement(ref workerCount);
826	};
827	#endregion
828
829	#region work distribution
830	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
831	int outLen = outDims.NumberOfElements;
832	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
833	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
834	workItemLength = outLen / dimLen / workItemCount;
835	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
836	} else {
837	workItemLength = outLen / dimLen / 2;
838	workItemCount = 2;
839	}
840	} else {
841	workItemLength = outLen / dimLen;
842	workItemCount = 1;
843	}
844
845	fixed ( Int32* arrAP = arrA)
846	fixed ( Int32* arrBP = arrB)
847	fixed (byte* retArrP = retArr) {
848
849	for (; i < workItemCount - 1; i++) {
850	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
851	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
852	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
853	System.Threading.Interlocked.Increment(ref workerCount);
854	ILThreadPool.QueueUserWorkItem(i, worker, range);
855	}
856	// the last (or may the only) chunk is done right here
857	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
858	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
859	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
860
861	ILThreadPool.Wait4Workers(ref workerCount);
862	}
863	#endregion
864
865	return new ILRetLogical(retStorage);
866	}
867	}
868
869	/// <summary>Elementwise logical 'equal' operator</summary>
870	/// <param name="A">Input array A</param>
871	/// <param name="B">Input array B</param>
872	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
873	/// <remarks><para>On empty input an empty array will be returned.</para>
874	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
875	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
876	public unsafe static ILRetLogical eq(ILInArray<float> A, ILInArray<float> B) {
877	using (ILScope.Enter(A, B)) {
878	int outLen;
879	BinOpItMode mode;
880	byte[] retArr;
881
882	float[] arrA = A.GetArrayForRead();
883
884	float[] arrB = B.GetArrayForRead();
885	ILSize outDims;
886	if (A.IsScalar) {
887	if (B.IsScalar) {
888
889	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
890	} else if (B.IsEmpty) {
891	return new ILRetLogical(B.Size);
892	} else {
893	outLen = B.S.NumberOfElements;
894	retArr = ILMemoryPool.Pool.New<byte>(outLen);
895	mode = BinOpItMode.SAN;
896	}
897	outDims = B.Size;
898	} else {
899	outDims = A.Size;
900	if (B.IsScalar) {
901	if (A.IsEmpty) {
902	return new ILRetLogical(A.Size);
903	}
904	outLen = A.S.NumberOfElements;
905	retArr = ILMemoryPool.Pool.New<byte>(outLen);
906	mode = BinOpItMode.ASN;
907	} else {
908	// array + array
909	if (!A.Size.IsSameSize(B.Size)) {
910	return eqEx(A,B);
911	}
912	outLen = A.S.NumberOfElements;
913	retArr = ILMemoryPool.Pool.New<byte>(outLen);
914	mode = BinOpItMode.AAN;
915	}
916	}
917	int workerCount = 1;
918	Action<object> worker = data => {
919	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
920	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
921	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
922	float scalar;
923	cLast = cp + range.Item2;
924	#region loops
925	switch (mode) {
926	case BinOpItMode.AAN:
927	float* ap = ((float*)range.Item3 + range.Item1);
928	float* bp = ((float*)range.Item4 + range.Item1);
929	while (cp < cLast) {
930
931	cp = (ap == *bp) ? (byte)1 : (byte)0;
932	cp++;
933	ap++;
934	bp++;
935	}
936	break;
937	case BinOpItMode.ASN:
938	ap = ((float*)range.Item3 + range.Item1);
939	scalar = ((float)range.Item4);
940	while (cp < cLast) {
941
942	cp = (ap == scalar) ? (byte)1 : (byte)0;
943	cp++;
944	ap++;
945
946	}
947	break;
948	case BinOpItMode.SAN:
949	scalar = ((float)range.Item3);
950	bp = ((float*)range.Item4 + range.Item1);
951	while (cp < cLast) {
952
953	cp = (scalar == bp) ? (byte)1 : (byte)0;
954	cp++;
955	bp++;
956	}
957	break;
958	default:
959	break;
960	}
961	#endregion
962	System.Threading.Interlocked.Decrement(ref workerCount);
963	};
964
965	#region do the work
966	fixed (float* arrAP = arrA)
967	fixed (float* arrBP = arrB)
968	fixed (byte* retArrP = retArr) {
969	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
970	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
971	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
972	workItemLength = outLen / workItemCount;
973	} else {
974	workItemLength = outLen / 2;
975	workItemCount = 2;
976	}
977	} else {
978	workItemLength = outLen;
979	workItemCount = 1;
980	}
981
982	for (; i < workItemCount - 1; i++) {
983	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
984	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
985	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
986	System.Threading.Interlocked.Increment(ref workerCount);
987	ILThreadPool.QueueUserWorkItem(i, worker, range);
988	}
989	// the last (or may the only) chunk is done right here
990	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
991	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
992	ILThreadPool.Wait4Workers(ref workerCount);
993	}
994
995	#endregion
996	return new ILRetLogical(retArr, outDims);
997	}
998	}
999
1000	private static unsafe ILRetLogical eqEx(ILInArray<float> A, ILInArray<float> B) {
1001	using (ILScope.Enter(A, B)) {
1002	#region parameter checking
1003	if (isnull(A) \|\| isnull(B))
1004	return new ILRetLogical(ILSize.Empty00);
1005	if (A.IsEmpty) {
1006	return new ILRetLogical(B.S);
1007	} else if (B.IsEmpty) {
1008	return new ILRetLogical(A.S);
1009	}
1010	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
1011	// return add(A,B);
1012	int dim = -1;
1013	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
1014	if (A.S[l] != B.S[l]) {
1015	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
1016	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1017	}
1018	dim = l;
1019	}
1020	}
1021	if (dim > 1)
1022	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
1023	#endregion
1024
1025	#region parameter preparation
1026	byte[] retArr;
1027
1028	float[] arrA = A.GetArrayForRead();
1029
1030	float[] arrB = B.GetArrayForRead();
1031	ILSize outDims;
1032	BinOptItExMode mode;
1033	int arrInc = 0;
1034	int arrStepInc = 0;
1035	int dimLen = 0;
1036	if (A.IsVector) {
1037	outDims = B.S;
1038	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1039	mode = BinOptItExMode.VAN;
1040	dimLen = A.Length;
1041	} else if (B.IsVector) {
1042	outDims = A.S;
1043	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1044	mode = BinOptItExMode.AVN;
1045	dimLen = B.Length;
1046	} else {
1047	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1048	}
1049	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
1050	arrStepInc = outDims.SequentialIndexDistance(dim);
1051	#endregion
1052
1053	#region worker loops definition
1054	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
1055	int workerCount = 1;
1056	Action<object> worker = data => {
1057	// expects: iStart, iLen, ap, bp, cp
1058	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
1059	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
1060
1061	float* ap;
1062
1063	float* bp;
1064	byte* cp;
1065	switch (mode) {
1066	case BinOptItExMode.VAN:
1067	for (int s = 0; s < range.Item2; s++) {
1068	ap = (float*)range.Item3;
1069	bp = (float)range.Item4 + range.Item1 + s arrStepInc; ;
1070	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1071	for (int l = 0; l < dimLen; l++) {
1072
1073	cp = (ap == *bp) ? (byte)1 : (byte)0;
1074	ap++;
1075	bp += arrInc;
1076	cp += arrInc;
1077	}
1078	}
1079	break;
1080	case BinOptItExMode.AVN:
1081	for (int s = 0; s < range.Item2; s++) {
1082	ap = (float)range.Item3 + range.Item1 + s arrStepInc;
1083	bp = (float*)range.Item4;
1084	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1085	for (int l = 0; l < dimLen; l++) {
1086
1087	cp = (ap == *bp) ? (byte)1 : (byte)0;
1088	ap += arrInc;
1089	bp++;
1090	cp += arrInc;
1091	}
1092	}
1093	break;
1094	}
1095	System.Threading.Interlocked.Decrement(ref workerCount);
1096	};
1097	#endregion
1098
1099	#region work distribution
1100	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1101	int outLen = outDims.NumberOfElements;
1102	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
1103	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1104	workItemLength = outLen / dimLen / workItemCount;
1105	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
1106	} else {
1107	workItemLength = outLen / dimLen / 2;
1108	workItemCount = 2;
1109	}
1110	} else {
1111	workItemLength = outLen / dimLen;
1112	workItemCount = 1;
1113	}
1114
1115	fixed ( float* arrAP = arrA)
1116	fixed ( float* arrBP = arrB)
1117	fixed (byte* retArrP = retArr) {
1118
1119	for (; i < workItemCount - 1; i++) {
1120	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
1121	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1122	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
1123	System.Threading.Interlocked.Increment(ref workerCount);
1124	ILThreadPool.QueueUserWorkItem(i, worker, range);
1125	}
1126	// the last (or may the only) chunk is done right here
1127	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
1128	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1129	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
1130
1131	ILThreadPool.Wait4Workers(ref workerCount);
1132	}
1133	#endregion
1134
1135	return new ILRetLogical(retStorage);
1136	}
1137	}
1138
1139	/// <summary>Elementwise logical 'equal' operator</summary>
1140	/// <param name="A">Input array A</param>
1141	/// <param name="B">Input array B</param>
1142	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
1143	/// <remarks><para>On empty input an empty array will be returned.</para>
1144	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
1145	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
1146	public unsafe static ILRetLogical eq(ILInArray<fcomplex> A, ILInArray<fcomplex> B) {
1147	using (ILScope.Enter(A, B)) {
1148	int outLen;
1149	BinOpItMode mode;
1150	byte[] retArr;
1151
1152	fcomplex[] arrA = A.GetArrayForRead();
1153
1154	fcomplex[] arrB = B.GetArrayForRead();
1155	ILSize outDims;
1156	if (A.IsScalar) {
1157	if (B.IsScalar) {
1158
1159	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
1160	} else if (B.IsEmpty) {
1161	return new ILRetLogical(B.Size);
1162	} else {
1163	outLen = B.S.NumberOfElements;
1164	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1165	mode = BinOpItMode.SAN;
1166	}
1167	outDims = B.Size;
1168	} else {
1169	outDims = A.Size;
1170	if (B.IsScalar) {
1171	if (A.IsEmpty) {
1172	return new ILRetLogical(A.Size);
1173	}
1174	outLen = A.S.NumberOfElements;
1175	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1176	mode = BinOpItMode.ASN;
1177	} else {
1178	// array + array
1179	if (!A.Size.IsSameSize(B.Size)) {
1180	return eqEx(A,B);
1181	}
1182	outLen = A.S.NumberOfElements;
1183	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1184	mode = BinOpItMode.AAN;
1185	}
1186	}
1187	int workerCount = 1;
1188	Action<object> worker = data => {
1189	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1190	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
1191	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
1192	fcomplex scalar;
1193	cLast = cp + range.Item2;
1194	#region loops
1195	switch (mode) {
1196	case BinOpItMode.AAN:
1197	fcomplex* ap = ((fcomplex*)range.Item3 + range.Item1);
1198	fcomplex* bp = ((fcomplex*)range.Item4 + range.Item1);
1199	while (cp < cLast) {
1200
1201	cp = (ap == *bp) ? (byte)1 : (byte)0;
1202	cp++;
1203	ap++;
1204	bp++;
1205	}
1206	break;
1207	case BinOpItMode.ASN:
1208	ap = ((fcomplex*)range.Item3 + range.Item1);
1209	scalar = ((fcomplex)range.Item4);
1210	while (cp < cLast) {
1211
1212	cp = (ap == scalar) ? (byte)1 : (byte)0;
1213	cp++;
1214	ap++;
1215
1216	}
1217	break;
1218	case BinOpItMode.SAN:
1219	scalar = ((fcomplex)range.Item3);
1220	bp = ((fcomplex*)range.Item4 + range.Item1);
1221	while (cp < cLast) {
1222
1223	cp = (scalar == bp) ? (byte)1 : (byte)0;
1224	cp++;
1225	bp++;
1226	}
1227	break;
1228	default:
1229	break;
1230	}
1231	#endregion
1232	System.Threading.Interlocked.Decrement(ref workerCount);
1233	};
1234
1235	#region do the work
1236	fixed (fcomplex* arrAP = arrA)
1237	fixed (fcomplex* arrBP = arrB)
1238	fixed (byte* retArrP = retArr) {
1239	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1240	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
1241	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1242	workItemLength = outLen / workItemCount;
1243	} else {
1244	workItemLength = outLen / 2;
1245	workItemCount = 2;
1246	}
1247	} else {
1248	workItemLength = outLen;
1249	workItemCount = 1;
1250	}
1251
1252	for (; i < workItemCount - 1; i++) {
1253	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1254	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1255	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
1256	System.Threading.Interlocked.Increment(ref workerCount);
1257	ILThreadPool.QueueUserWorkItem(i, worker, range);
1258	}
1259	// the last (or may the only) chunk is done right here
1260	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1261	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
1262	ILThreadPool.Wait4Workers(ref workerCount);
1263	}
1264
1265	#endregion
1266	return new ILRetLogical(retArr, outDims);
1267	}
1268	}
1269
1270	private static unsafe ILRetLogical eqEx(ILInArray<fcomplex> A, ILInArray<fcomplex> B) {
1271	using (ILScope.Enter(A, B)) {
1272	#region parameter checking
1273	if (isnull(A) \|\| isnull(B))
1274	return new ILRetLogical(ILSize.Empty00);
1275	if (A.IsEmpty) {
1276	return new ILRetLogical(B.S);
1277	} else if (B.IsEmpty) {
1278	return new ILRetLogical(A.S);
1279	}
1280	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
1281	// return add(A,B);
1282	int dim = -1;
1283	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
1284	if (A.S[l] != B.S[l]) {
1285	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
1286	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1287	}
1288	dim = l;
1289	}
1290	}
1291	if (dim > 1)
1292	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
1293	#endregion
1294
1295	#region parameter preparation
1296	byte[] retArr;
1297
1298	fcomplex[] arrA = A.GetArrayForRead();
1299
1300	fcomplex[] arrB = B.GetArrayForRead();
1301	ILSize outDims;
1302	BinOptItExMode mode;
1303	int arrInc = 0;
1304	int arrStepInc = 0;
1305	int dimLen = 0;
1306	if (A.IsVector) {
1307	outDims = B.S;
1308	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1309	mode = BinOptItExMode.VAN;
1310	dimLen = A.Length;
1311	} else if (B.IsVector) {
1312	outDims = A.S;
1313	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1314	mode = BinOptItExMode.AVN;
1315	dimLen = B.Length;
1316	} else {
1317	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1318	}
1319	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
1320	arrStepInc = outDims.SequentialIndexDistance(dim);
1321	#endregion
1322
1323	#region worker loops definition
1324	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
1325	int workerCount = 1;
1326	Action<object> worker = data => {
1327	// expects: iStart, iLen, ap, bp, cp
1328	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
1329	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
1330
1331	fcomplex* ap;
1332
1333	fcomplex* bp;
1334	byte* cp;
1335	switch (mode) {
1336	case BinOptItExMode.VAN:
1337	for (int s = 0; s < range.Item2; s++) {
1338	ap = (fcomplex*)range.Item3;
1339	bp = (fcomplex)range.Item4 + range.Item1 + s arrStepInc; ;
1340	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1341	for (int l = 0; l < dimLen; l++) {
1342
1343	cp = (ap == *bp) ? (byte)1 : (byte)0;
1344	ap++;
1345	bp += arrInc;
1346	cp += arrInc;
1347	}
1348	}
1349	break;
1350	case BinOptItExMode.AVN:
1351	for (int s = 0; s < range.Item2; s++) {
1352	ap = (fcomplex)range.Item3 + range.Item1 + s arrStepInc;
1353	bp = (fcomplex*)range.Item4;
1354	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1355	for (int l = 0; l < dimLen; l++) {
1356
1357	cp = (ap == *bp) ? (byte)1 : (byte)0;
1358	ap += arrInc;
1359	bp++;
1360	cp += arrInc;
1361	}
1362	}
1363	break;
1364	}
1365	System.Threading.Interlocked.Decrement(ref workerCount);
1366	};
1367	#endregion
1368
1369	#region work distribution
1370	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1371	int outLen = outDims.NumberOfElements;
1372	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
1373	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1374	workItemLength = outLen / dimLen / workItemCount;
1375	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
1376	} else {
1377	workItemLength = outLen / dimLen / 2;
1378	workItemCount = 2;
1379	}
1380	} else {
1381	workItemLength = outLen / dimLen;
1382	workItemCount = 1;
1383	}
1384
1385	fixed ( fcomplex* arrAP = arrA)
1386	fixed ( fcomplex* arrBP = arrB)
1387	fixed (byte* retArrP = retArr) {
1388
1389	for (; i < workItemCount - 1; i++) {
1390	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
1391	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1392	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
1393	System.Threading.Interlocked.Increment(ref workerCount);
1394	ILThreadPool.QueueUserWorkItem(i, worker, range);
1395	}
1396	// the last (or may the only) chunk is done right here
1397	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
1398	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1399	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
1400
1401	ILThreadPool.Wait4Workers(ref workerCount);
1402	}
1403	#endregion
1404
1405	return new ILRetLogical(retStorage);
1406	}
1407	}
1408
1409	/// <summary>Elementwise logical 'equal' operator</summary>
1410	/// <param name="A">Input array A</param>
1411	/// <param name="B">Input array B</param>
1412	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
1413	/// <remarks><para>On empty input an empty array will be returned.</para>
1414	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
1415	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
1416	public unsafe static ILRetLogical eq(ILInArray<complex> A, ILInArray<complex> B) {
1417	using (ILScope.Enter(A, B)) {
1418	int outLen;
1419	BinOpItMode mode;
1420	byte[] retArr;
1421
1422	complex[] arrA = A.GetArrayForRead();
1423
1424	complex[] arrB = B.GetArrayForRead();
1425	ILSize outDims;
1426	if (A.IsScalar) {
1427	if (B.IsScalar) {
1428
1429	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
1430	} else if (B.IsEmpty) {
1431	return new ILRetLogical(B.Size);
1432	} else {
1433	outLen = B.S.NumberOfElements;
1434	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1435	mode = BinOpItMode.SAN;
1436	}
1437	outDims = B.Size;
1438	} else {
1439	outDims = A.Size;
1440	if (B.IsScalar) {
1441	if (A.IsEmpty) {
1442	return new ILRetLogical(A.Size);
1443	}
1444	outLen = A.S.NumberOfElements;
1445	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1446	mode = BinOpItMode.ASN;
1447	} else {
1448	// array + array
1449	if (!A.Size.IsSameSize(B.Size)) {
1450	return eqEx(A,B);
1451	}
1452	outLen = A.S.NumberOfElements;
1453	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1454	mode = BinOpItMode.AAN;
1455	}
1456	}
1457	int workerCount = 1;
1458	Action<object> worker = data => {
1459	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1460	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
1461	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
1462	complex scalar;
1463	cLast = cp + range.Item2;
1464	#region loops
1465	switch (mode) {
1466	case BinOpItMode.AAN:
1467	complex* ap = ((complex*)range.Item3 + range.Item1);
1468	complex* bp = ((complex*)range.Item4 + range.Item1);
1469	while (cp < cLast) {
1470
1471	cp = (ap == *bp) ? (byte)1 : (byte)0;
1472	cp++;
1473	ap++;
1474	bp++;
1475	}
1476	break;
1477	case BinOpItMode.ASN:
1478	ap = ((complex*)range.Item3 + range.Item1);
1479	scalar = ((complex)range.Item4);
1480	while (cp < cLast) {
1481
1482	cp = (ap == scalar) ? (byte)1 : (byte)0;
1483	cp++;
1484	ap++;
1485
1486	}
1487	break;
1488	case BinOpItMode.SAN:
1489	scalar = ((complex)range.Item3);
1490	bp = ((complex*)range.Item4 + range.Item1);
1491	while (cp < cLast) {
1492
1493	cp = (scalar == bp) ? (byte)1 : (byte)0;
1494	cp++;
1495	bp++;
1496	}
1497	break;
1498	default:
1499	break;
1500	}
1501	#endregion
1502	System.Threading.Interlocked.Decrement(ref workerCount);
1503	};
1504
1505	#region do the work
1506	fixed (complex* arrAP = arrA)
1507	fixed (complex* arrBP = arrB)
1508	fixed (byte* retArrP = retArr) {
1509	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1510	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
1511	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1512	workItemLength = outLen / workItemCount;
1513	} else {
1514	workItemLength = outLen / 2;
1515	workItemCount = 2;
1516	}
1517	} else {
1518	workItemLength = outLen;
1519	workItemCount = 1;
1520	}
1521
1522	for (; i < workItemCount - 1; i++) {
1523	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1524	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1525	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
1526	System.Threading.Interlocked.Increment(ref workerCount);
1527	ILThreadPool.QueueUserWorkItem(i, worker, range);
1528	}
1529	// the last (or may the only) chunk is done right here
1530	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1531	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
1532	ILThreadPool.Wait4Workers(ref workerCount);
1533	}
1534
1535	#endregion
1536	return new ILRetLogical(retArr, outDims);
1537	}
1538	}
1539
1540	private static unsafe ILRetLogical eqEx(ILInArray<complex> A, ILInArray<complex> B) {
1541	using (ILScope.Enter(A, B)) {
1542	#region parameter checking
1543	if (isnull(A) \|\| isnull(B))
1544	return new ILRetLogical(ILSize.Empty00);
1545	if (A.IsEmpty) {
1546	return new ILRetLogical(B.S);
1547	} else if (B.IsEmpty) {
1548	return new ILRetLogical(A.S);
1549	}
1550	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
1551	// return add(A,B);
1552	int dim = -1;
1553	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
1554	if (A.S[l] != B.S[l]) {
1555	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
1556	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1557	}
1558	dim = l;
1559	}
1560	}
1561	if (dim > 1)
1562	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
1563	#endregion
1564
1565	#region parameter preparation
1566	byte[] retArr;
1567
1568	complex[] arrA = A.GetArrayForRead();
1569
1570	complex[] arrB = B.GetArrayForRead();
1571	ILSize outDims;
1572	BinOptItExMode mode;
1573	int arrInc = 0;
1574	int arrStepInc = 0;
1575	int dimLen = 0;
1576	if (A.IsVector) {
1577	outDims = B.S;
1578	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1579	mode = BinOptItExMode.VAN;
1580	dimLen = A.Length;
1581	} else if (B.IsVector) {
1582	outDims = A.S;
1583	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1584	mode = BinOptItExMode.AVN;
1585	dimLen = B.Length;
1586	} else {
1587	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1588	}
1589	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
1590	arrStepInc = outDims.SequentialIndexDistance(dim);
1591	#endregion
1592
1593	#region worker loops definition
1594	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
1595	int workerCount = 1;
1596	Action<object> worker = data => {
1597	// expects: iStart, iLen, ap, bp, cp
1598	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
1599	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
1600
1601	complex* ap;
1602
1603	complex* bp;
1604	byte* cp;
1605	switch (mode) {
1606	case BinOptItExMode.VAN:
1607	for (int s = 0; s < range.Item2; s++) {
1608	ap = (complex*)range.Item3;
1609	bp = (complex)range.Item4 + range.Item1 + s arrStepInc; ;
1610	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1611	for (int l = 0; l < dimLen; l++) {
1612
1613	cp = (ap == *bp) ? (byte)1 : (byte)0;
1614	ap++;
1615	bp += arrInc;
1616	cp += arrInc;
1617	}
1618	}
1619	break;
1620	case BinOptItExMode.AVN:
1621	for (int s = 0; s < range.Item2; s++) {
1622	ap = (complex)range.Item3 + range.Item1 + s arrStepInc;
1623	bp = (complex*)range.Item4;
1624	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1625	for (int l = 0; l < dimLen; l++) {
1626
1627	cp = (ap == *bp) ? (byte)1 : (byte)0;
1628	ap += arrInc;
1629	bp++;
1630	cp += arrInc;
1631	}
1632	}
1633	break;
1634	}
1635	System.Threading.Interlocked.Decrement(ref workerCount);
1636	};
1637	#endregion
1638
1639	#region work distribution
1640	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1641	int outLen = outDims.NumberOfElements;
1642	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
1643	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1644	workItemLength = outLen / dimLen / workItemCount;
1645	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
1646	} else {
1647	workItemLength = outLen / dimLen / 2;
1648	workItemCount = 2;
1649	}
1650	} else {
1651	workItemLength = outLen / dimLen;
1652	workItemCount = 1;
1653	}
1654
1655	fixed ( complex* arrAP = arrA)
1656	fixed ( complex* arrBP = arrB)
1657	fixed (byte* retArrP = retArr) {
1658
1659	for (; i < workItemCount - 1; i++) {
1660	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
1661	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1662	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
1663	System.Threading.Interlocked.Increment(ref workerCount);
1664	ILThreadPool.QueueUserWorkItem(i, worker, range);
1665	}
1666	// the last (or may the only) chunk is done right here
1667	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
1668	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1669	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
1670
1671	ILThreadPool.Wait4Workers(ref workerCount);
1672	}
1673	#endregion
1674
1675	return new ILRetLogical(retStorage);
1676	}
1677	}
1678
1679	/// <summary>Elementwise logical 'equal' operator</summary>
1680	/// <param name="A">Input array A</param>
1681	/// <param name="B">Input array B</param>
1682	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
1683	/// <remarks><para>On empty input an empty array will be returned.</para>
1684	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para></remarks>
1685	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither A nor B is scalar or empty, the dimensions of both arrays must match.</exception>
1686	public unsafe static ILRetLogical eq(ILInArray<byte> A, ILInArray<byte> B) {
1687	using (ILScope.Enter(A, B)) {
1688	int outLen;
1689	BinOpItMode mode;
1690	byte[] retArr;
1691
1692	byte[] arrA = A.GetArrayForRead();
1693
1694	byte[] arrB = B.GetArrayForRead();
1695	ILSize outDims;
1696	if (A.IsScalar) {
1697	if (B.IsScalar) {
1698
1699	return new ILRetLogical(new byte[1] { (A.GetValue(0) == B.GetValue(0)) ? (byte)1 : (byte)0 });
1700	} else if (B.IsEmpty) {
1701	return new ILRetLogical(B.Size);
1702	} else {
1703	outLen = B.S.NumberOfElements;
1704	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1705	mode = BinOpItMode.SAN;
1706	}
1707	outDims = B.Size;
1708	} else {
1709	outDims = A.Size;
1710	if (B.IsScalar) {
1711	if (A.IsEmpty) {
1712	return new ILRetLogical(A.Size);
1713	}
1714	outLen = A.S.NumberOfElements;
1715	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1716	mode = BinOpItMode.ASN;
1717	} else {
1718	// array + array
1719	if (!A.Size.IsSameSize(B.Size)) {
1720	return eqEx(A,B);
1721	}
1722	outLen = A.S.NumberOfElements;
1723	retArr = ILMemoryPool.Pool.New<byte>(outLen);
1724	mode = BinOpItMode.AAN;
1725	}
1726	}
1727	int workerCount = 1;
1728	Action<object> worker = data => {
1729	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1730	= (Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>)data;
1731	byte* cLast, cp = (byte*)range.Item5 + range.Item1;
1732	byte scalar;
1733	cLast = cp + range.Item2;
1734	#region loops
1735	switch (mode) {
1736	case BinOpItMode.AAN:
1737	byte* ap = ((byte*)range.Item3 + range.Item1);
1738	byte* bp = ((byte*)range.Item4 + range.Item1);
1739	while (cp < cLast) {
1740
1741	cp = (ap == *bp) ? (byte)1 : (byte)0;
1742	cp++;
1743	ap++;
1744	bp++;
1745	}
1746	break;
1747	case BinOpItMode.ASN:
1748	ap = ((byte*)range.Item3 + range.Item1);
1749	scalar = ((byte)range.Item4);
1750	while (cp < cLast) {
1751
1752	cp = (ap == scalar) ? (byte)1 : (byte)0;
1753	cp++;
1754	ap++;
1755
1756	}
1757	break;
1758	case BinOpItMode.SAN:
1759	scalar = ((byte)range.Item3);
1760	bp = ((byte*)range.Item4 + range.Item1);
1761	while (cp < cLast) {
1762
1763	cp = (scalar == bp) ? (byte)1 : (byte)0;
1764	cp++;
1765	bp++;
1766	}
1767	break;
1768	default:
1769	break;
1770	}
1771	#endregion
1772	System.Threading.Interlocked.Decrement(ref workerCount);
1773	};
1774
1775	#region do the work
1776	fixed (byte* arrAP = arrA)
1777	fixed (byte* arrBP = arrB)
1778	fixed (byte* retArrP = retArr) {
1779	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1780	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
1781	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1782	workItemLength = outLen / workItemCount;
1783	} else {
1784	workItemLength = outLen / 2;
1785	workItemCount = 2;
1786	}
1787	} else {
1788	workItemLength = outLen;
1789	workItemCount = 1;
1790	}
1791
1792	for (; i < workItemCount - 1; i++) {
1793	Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode> range
1794	= new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1795	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode);
1796	System.Threading.Interlocked.Increment(ref workerCount);
1797	ILThreadPool.QueueUserWorkItem(i, worker, range);
1798	}
1799	// the last (or may the only) chunk is done right here
1800	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr, BinOpItMode>
1801	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP, mode));
1802	ILThreadPool.Wait4Workers(ref workerCount);
1803	}
1804
1805	#endregion
1806	return new ILRetLogical(retArr, outDims);
1807	}
1808	}
1809
1810	private static unsafe ILRetLogical eqEx(ILInArray<byte> A, ILInArray<byte> B) {
1811	using (ILScope.Enter(A, B)) {
1812	#region parameter checking
1813	if (isnull(A) \|\| isnull(B))
1814	return new ILRetLogical(ILSize.Empty00);
1815	if (A.IsEmpty) {
1816	return new ILRetLogical(B.S);
1817	} else if (B.IsEmpty) {
1818	return new ILRetLogical(A.S);
1819	}
1820	//if (A.IsScalar \|\| B.IsScalar \|\| A.D.IsSameSize(B.D))
1821	// return add(A,B);
1822	int dim = -1;
1823	for (int l = 0; l < Math.Max(A.S.NumberOfDimensions, B.S.NumberOfDimensions); l++) {
1824	if (A.S[l] != B.S[l]) {
1825	if (dim >= 0 \|\| (A.S[l] != 1 && B.S[l] != 1)) {
1826	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1827	}
1828	dim = l;
1829	}
1830	}
1831	if (dim > 1)
1832	throw new ILArgumentException("singleton dimension expansion currently is only supported for colum- and row vectors");
1833	#endregion
1834
1835	#region parameter preparation
1836	byte[] retArr;
1837
1838	byte[] arrA = A.GetArrayForRead();
1839
1840	byte[] arrB = B.GetArrayForRead();
1841	ILSize outDims;
1842	BinOptItExMode mode;
1843	int arrInc = 0;
1844	int arrStepInc = 0;
1845	int dimLen = 0;
1846	if (A.IsVector) {
1847	outDims = B.S;
1848	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1849	mode = BinOptItExMode.VAN;
1850	dimLen = A.Length;
1851	} else if (B.IsVector) {
1852	outDims = A.S;
1853	retArr = ILMemoryPool.Pool.New<byte>(outDims.NumberOfElements);
1854	mode = BinOptItExMode.AVN;
1855	dimLen = B.Length;
1856	} else {
1857	throw new ILArgumentException("A and B must have the same size except for one simgleton dimension in A or B");
1858	}
1859	arrInc = (dim == 0) ? outDims.SequentialIndexDistance(1) : outDims.SequentialIndexDistance(0);
1860	arrStepInc = outDims.SequentialIndexDistance(dim);
1861	#endregion
1862
1863	#region worker loops definition
1864	ILLogicalStorage retStorage = new ILLogicalStorage(retArr, outDims);
1865	int workerCount = 1;
1866	Action<object> worker = data => {
1867	// expects: iStart, iLen, ap, bp, cp
1868	Tuple<int, int, IntPtr, IntPtr, IntPtr> range =
1869	(Tuple<int, int, IntPtr, IntPtr, IntPtr>)data;
1870
1871	byte* ap;
1872
1873	byte* bp;
1874	byte* cp;
1875	switch (mode) {
1876	case BinOptItExMode.VAN:
1877	for (int s = 0; s < range.Item2; s++) {
1878	ap = (byte*)range.Item3;
1879	bp = (byte)range.Item4 + range.Item1 + s arrStepInc; ;
1880	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1881	for (int l = 0; l < dimLen; l++) {
1882
1883	cp = (ap == *bp) ? (byte)1 : (byte)0;
1884	ap++;
1885	bp += arrInc;
1886	cp += arrInc;
1887	}
1888	}
1889	break;
1890	case BinOptItExMode.AVN:
1891	for (int s = 0; s < range.Item2; s++) {
1892	ap = (byte)range.Item3 + range.Item1 + s arrStepInc;
1893	bp = (byte*)range.Item4;
1894	cp = (byte)range.Item5 + range.Item1 + s arrStepInc;
1895	for (int l = 0; l < dimLen; l++) {
1896
1897	cp = (ap == *bp) ? (byte)1 : (byte)0;
1898	ap += arrInc;
1899	bp++;
1900	cp += arrInc;
1901	}
1902	}
1903	break;
1904	}
1905	System.Threading.Interlocked.Decrement(ref workerCount);
1906	};
1907	#endregion
1908
1909	#region work distribution
1910	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength;
1911	int outLen = outDims.NumberOfElements;
1912	if (Settings.s_maxNumberThreads > 1 && outLen / 2 >= Settings.s_minParallelElement1Count) {
1913	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
1914	workItemLength = outLen / dimLen / workItemCount;
1915	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
1916	} else {
1917	workItemLength = outLen / dimLen / 2;
1918	workItemCount = 2;
1919	}
1920	} else {
1921	workItemLength = outLen / dimLen;
1922	workItemCount = 1;
1923	}
1924
1925	fixed ( byte* arrAP = arrA)
1926	fixed ( byte* arrBP = arrB)
1927	fixed (byte* retArrP = retArr) {
1928
1929	for (; i < workItemCount - 1; i++) {
1930	Tuple<int, int, IntPtr, IntPtr, IntPtr> range
1931	= new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1932	(i * workItemLength * arrStepInc, workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP);
1933	System.Threading.Interlocked.Increment(ref workerCount);
1934	ILThreadPool.QueueUserWorkItem(i, worker, range);
1935	}
1936	// the last (or may the only) chunk is done right here
1937	//System.Threading.Interlocked.Increment(ref retStorage.PendingTasks);
1938	worker(new Tuple<int, int, IntPtr, IntPtr, IntPtr>
1939	(i * workItemLength * arrStepInc, (outLen / dimLen) - i * workItemLength, (IntPtr)arrAP, (IntPtr)arrBP, (IntPtr)retArrP));
1940
1941	ILThreadPool.Wait4Workers(ref workerCount);
1942	}
1943	#endregion
1944
1945	return new ILRetLogical(retStorage);
1946	}
1947	}
1948
1949
1950	#endregion HYCALPER AUTO GENERATED CODE
1951
1952	/// <summary>
1953	/// Elementwise logical 'equal' operator
1954	/// </summary>
1955	/// <param name="A">Input array 1</param>
1956	/// <param name="B">Input array 2</param>
1957	/// <returns>Logical array having '1' for equal elements in A and B, '0' else</returns>
1958	/// <remarks><para>On empty input - empty array will be returned.</para>
1959	/// <para>A and/or B may be scalar. The scalar value will be applied on all elements of the other array.</para>
1960	/// <para>If neither of A or B is scalar or empty, the dimensions of both arrays must match.</para></remarks>
1961	/// <exception cref="ILNumerics.Exceptions.ILDimensionMismatchException">If neither of A or B is scalar and the size of both arrays does not match.</exception>
1962	public static ILRetLogical eq (ILInArray<String> A, ILInArray<String> B) {
1963	if (object.Equals(A,null))
1964	throw new ILArgumentException("eq: input argurment A must not be null!");
1965	if (object.Equals(B,null))
1966	throw new ILArgumentException("eq: input argurment B must not be null!");
1967	if (!A.Size.IsSameShape(B.Size))
1968	throw new ILArgumentException("input arrays must have the same size");
1969	if (A.IsEmpty \|\| B.IsEmpty)
1970	return new ILRetLogical(ILSize.Empty00);
1971	string scalarValue;
1972	ILSize retDim = null;
1973	byte[] retArr = null;
1974	if (A.IsScalar) {
1975	if (B.IsScalar) {
1976	retDim = new ILSize(1,1);
1977	return new ILRetLogical(new byte[1]{(A.GetValue(0) == B.GetValue(0))?(byte)1:(byte)0},1,1);
1978	} else {
1979	retDim = B.Size;
1980	int len = B.Size.NumberOfElements;
1981	retArr = new byte[len];
1982	scalarValue = (string)A.GetValue(0);
1983	for (int i = 0; i < len; i++) {
1984	if (scalarValue == (string)B.GetValue(i)) {
1985	retArr[i] = 1;
1986	}
1987	}
1988	}
1989	} else {
1990	retDim = A.Size;
1991	if (B.IsScalar) {
1992	int len = A.Size.NumberOfElements;
1993	retArr = new byte[len];
1994	scalarValue = B.GetValue(0);
1995	for (int i = 0; i < len; i++) {
1996	if (scalarValue == A.GetValue(i))
1997	retArr[i] = 1;
1998	}
1999	} else {
2000	if (!A.Size.IsSameSize(B.Size))
2001	throw new ILDimensionMismatchException("eq: size of arrays must match!");
2002	int len = A.Size.NumberOfElements;
2003	retArr = new byte[len];
2004	for (int i = 0; i < len; i++) {
2005	if (A.GetValue(i) == B.GetValue(i))
2006	retArr[i] = 1;
2007	}
2008	}
2009	}
2010	return new ILRetLogical(retArr,retDim);
2011	}
2012
2013	}
2014	}

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

Download in other formats:

Update cookies preferences