Context Navigation

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

Visit:

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

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

Download in other formats:

Update cookies preferences