Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/abs.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: 44.5 KB

Rev	Line
[9102]	1	///
	2	/// This file is part of ILNumerics Community Edition.
	3	///
	4	/// ILNumerics Community Edition - high performance computing for applications.
	5	/// Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
	6	///
	7	/// ILNumerics Community Edition is free software: you can redistribute it and/or modify
	8	/// it under the terms of the GNU General Public License version 3 as published by
	9	/// the Free Software Foundation.
	10	///
	11	/// ILNumerics Community Edition is distributed in the hope that it will be useful,
	12	/// but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	/// GNU General Public License for more details.
	15	///
	16	/// You should have received a copy of the GNU General Public License
	17	/// along with ILNumerics Community Edition. See the file License.txt in the root
	18	/// of your distribution package. If not, see <http://www.gnu.org/licenses/>.
	19	///
	20	/// In addition this software uses the following components and/or licenses:
	21	///
	22	/// =================================================================================
	23	/// The Open Toolkit Library License
	24	///
	25	/// Copyright (c) 2006 - 2009 the Open Toolkit library.
	26	///
	27	/// Permission is hereby granted, free of charge, to any person obtaining a copy
	28	/// of this software and associated documentation files (the "Software"), to deal
	29	/// in the Software without restriction, including without limitation the rights to
	30	/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	31	/// the Software, and to permit persons to whom the Software is furnished to do
	32	/// so, subject to the following conditions:
	33	///
	34	/// The above copyright notice and this permission notice shall be included in all
	35	/// copies or substantial portions of the Software.
	36	///
	37	/// =================================================================================
	38	///
	39
	40	using System;
	41	using System.Collections.Generic;
	42	using System.Text;
	43	using ILNumerics;
	44	using ILNumerics.Exceptions;
	45	using ILNumerics.Storage;
	46	using ILNumerics.Misc;
	47
	48
	49	namespace ILNumerics {
	50	public partial class ILMath {
	51	/// <summary>Absolute values of array elements</summary>
	52	/// <param name="A">Input Array</param>
	53	/// <returns>Absolute values of array elements</returns>
	54	/// <remarks><para>If the Input Array is empty, an empty array will be returned.</para>
	55	/// <para>The array returned will be a dense array.</para></remarks>
	56	public unsafe static ILRetArray<byte> abs(ILInArray<byte> A) {
	57	using (ILScope.Enter(A)) {
	58	return A.C;
	59	}
	60	}
	61
	62
	63
	64
	65	#region HYCALPER AUTO GENERATED CODE
	66
	67	/// <summary>Absolute values of array elements</summary>
	68	/// <param name="A">Input array</param>
	69	/// <returns>Absolute values of array elements</returns>
	70	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	71	/// <para>The array returned will be a dense array.</para></remarks>
	72	public unsafe static ILRetArray<double> abs (ILInArray< double > A) {
	73	using (ILScope.Enter(A)) {
	74	if (A.IsEmpty)
	75	return new ILRetArray<double>(A.Size);
	76	ILSize inDim = A.Size;
	77	double[] arrA = A.GetArrayForRead();
	78	double [] retArr;
	79	int outLen = inDim.NumberOfElements;
	80	bool inplace = true;
	81
	82	if (!A.TryGetStorage4InplaceOp(out retArr)){
	83	retArr = ILMemoryPool.Pool.New<double>(outLen);
	84	inplace = false;
	85	}
	86	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	87	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	88	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	89	workItemLength = outLen / workItemCount;
	90	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	91	} else {
	92	workItemLength = outLen / 2;
	93	workItemCount = 2;
	94	}
	95	} else {
	96	workItemLength = outLen;
	97	workItemCount = 1;
	98	}
	99	ILDenseStorage<double> retStorage = new ILDenseStorage<double>(retArr, inDim);
	100
	101	Action<object> worker = data => {
	102	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	103
	104	double* cp = ((double*)range.Item4 + range.Item1);
	105	int len = range.Item2;
	106	if (range.Item5) {
	107	// inplace
	108	while (len > 20) {
	109	cp[0] = Math.Abs(cp[0] ) /dummy/;
	110	cp[1] = Math.Abs(cp[1] ) /dummy/;
	111	cp[2] = Math.Abs(cp[2] ) /dummy/;
	112	cp[3] = Math.Abs(cp[3] ) /dummy/;
	113	cp[4] = Math.Abs(cp[4] ) /dummy/;
	114	cp[5] = Math.Abs(cp[5] ) /dummy/;
	115	cp[6] = Math.Abs(cp[6] ) /dummy/;
	116	cp[7] = Math.Abs(cp[7] ) /dummy/;
	117	cp[8] = Math.Abs(cp[8] ) /dummy/;
	118	cp[9] = Math.Abs(cp[9] ) /dummy/;
	119	cp[10] = Math.Abs(cp[10] ) /dummy/;
	120	cp[11] = Math.Abs(cp[11] ) /dummy/;
	121	cp[12] = Math.Abs(cp[12] ) /dummy/;
	122	cp[13] = Math.Abs(cp[13] ) /dummy/;
	123	cp[14] = Math.Abs(cp[14] ) /dummy/;
	124	cp[15] = Math.Abs(cp[15] ) /dummy/;
	125	cp[16] = Math.Abs(cp[16] ) /dummy/;
	126	cp[17] = Math.Abs(cp[17] ) /dummy/;
	127	cp[18] = Math.Abs(cp[18] ) /dummy/;
	128	cp[19] = Math.Abs(cp[19] ) /dummy/;
	129	cp[20] = Math.Abs(cp[20] ) /dummy/;
	130	cp+=21; len -= 21;
	131	}
	132	while (len-- > 0) {
	133	cp = Math.Abs(cp ) /dummy/;
	134	cp++;
	135	}
	136	} else {
	137	double* ap = ((double*)range.Item3 + range.Item1);
	138	while (len > 20) {
	139	cp[0] = Math.Abs(ap[0] ) /dummy/;
	140	cp[1] = Math.Abs(ap[1] ) /dummy/;
	141	cp[2] = Math.Abs(ap[2] ) /dummy/;
	142	cp[3] = Math.Abs(ap[3] ) /dummy/;
	143	cp[4] = Math.Abs(ap[4] ) /dummy/;
	144	cp[5] = Math.Abs(ap[5] ) /dummy/;
	145	cp[6] = Math.Abs(ap[6] ) /dummy/;
	146	cp[7] = Math.Abs(ap[7] ) /dummy/;
	147	cp[8] = Math.Abs(ap[8] ) /dummy/;
	148	cp[9] = Math.Abs(ap[9] ) /dummy/;
	149	cp[10] = Math.Abs(ap[10] ) /dummy/;
	150	cp[11] = Math.Abs(ap[11] ) /dummy/;
	151	cp[12] = Math.Abs(ap[12] ) /dummy/;
	152	cp[13] = Math.Abs(ap[13] ) /dummy/;
	153	cp[14] = Math.Abs(ap[14] ) /dummy/;
	154	cp[15] = Math.Abs(ap[15] ) /dummy/;
	155	cp[16] = Math.Abs(ap[16] ) /dummy/;
	156	cp[17] = Math.Abs(ap[17] ) /dummy/;
	157	cp[18] = Math.Abs(ap[18] ) /dummy/;
	158	cp[19] = Math.Abs(ap[19] ) /dummy/;
	159	cp[20] = Math.Abs(ap[20] ) /dummy/;
	160	ap += 21;
	161	cp += 21;
	162	len -= 21;
	163	}
	164	while (len-- > 0) {
	165	cp = Math.Abs(ap ) /dummy/;
	166	ap++;
	167	cp++;
	168	}
	169	}
	170	System.Threading.Interlocked.Decrement(ref workerCount);
	171	};
	172
	173	fixed ( double* arrAP = arrA)
	174	fixed ( double* retArrP = retArr) {
	175	for (; i < workItemCount - 1; i++) {
	176	Tuple<int, int, IntPtr, IntPtr, bool> range
	177	= new Tuple<int, int, IntPtr, IntPtr, bool>
	178	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	179	System.Threading.Interlocked.Increment(ref workerCount);
	180	ILThreadPool.QueueUserWorkItem(i,worker, range);
	181	}
	182	// the last (or may the only) chunk is done right here
	183	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	184	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	185
	186	ILThreadPool.Wait4Workers(ref workerCount);
	187	}
	188	return new ILRetArray<double>(retStorage);
	189	}
	190	}
	191	/// <summary>Absolute values of array elements</summary>
	192	/// <param name="A">Input array</param>
	193	/// <returns>Absolute values of array elements</returns>
	194	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	195	/// <para>The array returned will be a dense array.</para></remarks>
	196	public unsafe static ILRetArray<float> abs (ILInArray< float > A) {
	197	using (ILScope.Enter(A)) {
	198	if (A.IsEmpty)
	199	return new ILRetArray<float>(A.Size);
	200	ILSize inDim = A.Size;
	201	float[] arrA = A.GetArrayForRead();
	202	float [] retArr;
	203	int outLen = inDim.NumberOfElements;
	204	bool inplace = true;
	205
	206	if (!A.TryGetStorage4InplaceOp(out retArr)){
	207	retArr = ILMemoryPool.Pool.New<float>(outLen);
	208	inplace = false;
	209	}
	210	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	211	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	212	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	213	workItemLength = outLen / workItemCount;
	214	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	215	} else {
	216	workItemLength = outLen / 2;
	217	workItemCount = 2;
	218	}
	219	} else {
	220	workItemLength = outLen;
	221	workItemCount = 1;
	222	}
	223	ILDenseStorage<float> retStorage = new ILDenseStorage<float>(retArr, inDim);
	224
	225	Action<object> worker = data => {
	226	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	227
	228	float* cp = ((float*)range.Item4 + range.Item1);
	229	int len = range.Item2;
	230	if (range.Item5) {
	231	// inplace
	232	while (len > 20) {
	233	cp[0] = Math.Abs(cp[0] ) /dummy/;
	234	cp[1] = Math.Abs(cp[1] ) /dummy/;
	235	cp[2] = Math.Abs(cp[2] ) /dummy/;
	236	cp[3] = Math.Abs(cp[3] ) /dummy/;
	237	cp[4] = Math.Abs(cp[4] ) /dummy/;
	238	cp[5] = Math.Abs(cp[5] ) /dummy/;
	239	cp[6] = Math.Abs(cp[6] ) /dummy/;
	240	cp[7] = Math.Abs(cp[7] ) /dummy/;
	241	cp[8] = Math.Abs(cp[8] ) /dummy/;
	242	cp[9] = Math.Abs(cp[9] ) /dummy/;
	243	cp[10] = Math.Abs(cp[10] ) /dummy/;
	244	cp[11] = Math.Abs(cp[11] ) /dummy/;
	245	cp[12] = Math.Abs(cp[12] ) /dummy/;
	246	cp[13] = Math.Abs(cp[13] ) /dummy/;
	247	cp[14] = Math.Abs(cp[14] ) /dummy/;
	248	cp[15] = Math.Abs(cp[15] ) /dummy/;
	249	cp[16] = Math.Abs(cp[16] ) /dummy/;
	250	cp[17] = Math.Abs(cp[17] ) /dummy/;
	251	cp[18] = Math.Abs(cp[18] ) /dummy/;
	252	cp[19] = Math.Abs(cp[19] ) /dummy/;
	253	cp[20] = Math.Abs(cp[20] ) /dummy/;
	254	cp+=21; len -= 21;
	255	}
	256	while (len-- > 0) {
	257	cp = Math.Abs(cp ) /dummy/;
	258	cp++;
	259	}
	260	} else {
	261	float* ap = ((float*)range.Item3 + range.Item1);
	262	while (len > 20) {
	263	cp[0] = Math.Abs(ap[0] ) /dummy/;
	264	cp[1] = Math.Abs(ap[1] ) /dummy/;
	265	cp[2] = Math.Abs(ap[2] ) /dummy/;
	266	cp[3] = Math.Abs(ap[3] ) /dummy/;
	267	cp[4] = Math.Abs(ap[4] ) /dummy/;
	268	cp[5] = Math.Abs(ap[5] ) /dummy/;
	269	cp[6] = Math.Abs(ap[6] ) /dummy/;
	270	cp[7] = Math.Abs(ap[7] ) /dummy/;
	271	cp[8] = Math.Abs(ap[8] ) /dummy/;
	272	cp[9] = Math.Abs(ap[9] ) /dummy/;
	273	cp[10] = Math.Abs(ap[10] ) /dummy/;
	274	cp[11] = Math.Abs(ap[11] ) /dummy/;
	275	cp[12] = Math.Abs(ap[12] ) /dummy/;
	276	cp[13] = Math.Abs(ap[13] ) /dummy/;
	277	cp[14] = Math.Abs(ap[14] ) /dummy/;
	278	cp[15] = Math.Abs(ap[15] ) /dummy/;
	279	cp[16] = Math.Abs(ap[16] ) /dummy/;
	280	cp[17] = Math.Abs(ap[17] ) /dummy/;
	281	cp[18] = Math.Abs(ap[18] ) /dummy/;
	282	cp[19] = Math.Abs(ap[19] ) /dummy/;
	283	cp[20] = Math.Abs(ap[20] ) /dummy/;
	284	ap += 21;
	285	cp += 21;
	286	len -= 21;
	287	}
	288	while (len-- > 0) {
	289	cp = Math.Abs(ap ) /dummy/;
	290	ap++;
	291	cp++;
	292	}
	293	}
	294	System.Threading.Interlocked.Decrement(ref workerCount);
	295	};
	296
	297	fixed ( float* arrAP = arrA)
	298	fixed ( float* retArrP = retArr) {
	299	for (; i < workItemCount - 1; i++) {
	300	Tuple<int, int, IntPtr, IntPtr, bool> range
	301	= new Tuple<int, int, IntPtr, IntPtr, bool>
	302	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	303	System.Threading.Interlocked.Increment(ref workerCount);
	304	ILThreadPool.QueueUserWorkItem(i,worker, range);
	305	}
	306	// the last (or may the only) chunk is done right here
	307	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	308	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	309
	310	ILThreadPool.Wait4Workers(ref workerCount);
	311	}
	312	return new ILRetArray<float>(retStorage);
	313	}
	314	}
	315	/// <summary>Magnitude of array elements</summary>
	316	/// <param name="A">Input array</param>
	317	/// <returns>Magnitude of array elements</returns>
	318	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	319	/// <para>The array returned will be a dense array.</para></remarks>
	320	public unsafe static ILRetArray<float> abs (ILInArray< fcomplex > A) {
	321	using (ILScope.Enter(A)) {
	322	if (A.IsEmpty)
	323	return new ILRetArray<float>(A.Size);
	324	ILSize inDim = A.Size;
	325	fcomplex[] arrA = A.GetArrayForRead();
	326	float [] retArr;
	327	int outLen = inDim.NumberOfElements;
	328	bool inplace = true;
	329
	330	if (true){
	331	retArr = ILMemoryPool.Pool.New<float>(outLen);
	332	inplace = false;
	333	}
	334	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	335	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	336	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	337	workItemLength = outLen / workItemCount;
	338	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	339	} else {
	340	workItemLength = outLen / 2;
	341	workItemCount = 2;
	342	}
	343	} else {
	344	workItemLength = outLen;
	345	workItemCount = 1;
	346	}
	347	ILDenseStorage<float> retStorage = new ILDenseStorage<float>(retArr, inDim);
	348
	349	Action<object> worker = data => {
	350	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	351
	352	float* cp = ((float*)range.Item4 + range.Item1);
	353	int len = range.Item2;
	354	if (range.Item5) {
	355	// inplace
	356	while (len > 20) {
	357	cp[0] = fcomplex.Abs(cp[0] ) /dummy/;
	358	cp[1] = fcomplex.Abs(cp[1] ) /dummy/;
	359	cp[2] = fcomplex.Abs(cp[2] ) /dummy/;
	360	cp[3] = fcomplex.Abs(cp[3] ) /dummy/;
	361	cp[4] = fcomplex.Abs(cp[4] ) /dummy/;
	362	cp[5] = fcomplex.Abs(cp[5] ) /dummy/;
	363	cp[6] = fcomplex.Abs(cp[6] ) /dummy/;
	364	cp[7] = fcomplex.Abs(cp[7] ) /dummy/;
	365	cp[8] = fcomplex.Abs(cp[8] ) /dummy/;
	366	cp[9] = fcomplex.Abs(cp[9] ) /dummy/;
	367	cp[10] = fcomplex.Abs(cp[10] ) /dummy/;
	368	cp[11] = fcomplex.Abs(cp[11] ) /dummy/;
	369	cp[12] = fcomplex.Abs(cp[12] ) /dummy/;
	370	cp[13] = fcomplex.Abs(cp[13] ) /dummy/;
	371	cp[14] = fcomplex.Abs(cp[14] ) /dummy/;
	372	cp[15] = fcomplex.Abs(cp[15] ) /dummy/;
	373	cp[16] = fcomplex.Abs(cp[16] ) /dummy/;
	374	cp[17] = fcomplex.Abs(cp[17] ) /dummy/;
	375	cp[18] = fcomplex.Abs(cp[18] ) /dummy/;
	376	cp[19] = fcomplex.Abs(cp[19] ) /dummy/;
	377	cp[20] = fcomplex.Abs(cp[20] ) /dummy/;
	378	cp+=21; len -= 21;
	379	}
	380	while (len-- > 0) {
	381	cp = fcomplex.Abs(cp ) /dummy/;
	382	cp++;
	383	}
	384	} else {
	385	fcomplex* ap = ((fcomplex*)range.Item3 + range.Item1);
	386	while (len > 20) {
	387	cp[0] = fcomplex.Abs(ap[0] ) /dummy/;
	388	cp[1] = fcomplex.Abs(ap[1] ) /dummy/;
	389	cp[2] = fcomplex.Abs(ap[2] ) /dummy/;
	390	cp[3] = fcomplex.Abs(ap[3] ) /dummy/;
	391	cp[4] = fcomplex.Abs(ap[4] ) /dummy/;
	392	cp[5] = fcomplex.Abs(ap[5] ) /dummy/;
	393	cp[6] = fcomplex.Abs(ap[6] ) /dummy/;
	394	cp[7] = fcomplex.Abs(ap[7] ) /dummy/;
	395	cp[8] = fcomplex.Abs(ap[8] ) /dummy/;
	396	cp[9] = fcomplex.Abs(ap[9] ) /dummy/;
	397	cp[10] = fcomplex.Abs(ap[10] ) /dummy/;
	398	cp[11] = fcomplex.Abs(ap[11] ) /dummy/;
	399	cp[12] = fcomplex.Abs(ap[12] ) /dummy/;
	400	cp[13] = fcomplex.Abs(ap[13] ) /dummy/;
	401	cp[14] = fcomplex.Abs(ap[14] ) /dummy/;
	402	cp[15] = fcomplex.Abs(ap[15] ) /dummy/;
	403	cp[16] = fcomplex.Abs(ap[16] ) /dummy/;
	404	cp[17] = fcomplex.Abs(ap[17] ) /dummy/;
	405	cp[18] = fcomplex.Abs(ap[18] ) /dummy/;
	406	cp[19] = fcomplex.Abs(ap[19] ) /dummy/;
	407	cp[20] = fcomplex.Abs(ap[20] ) /dummy/;
	408	ap += 21;
	409	cp += 21;
	410	len -= 21;
	411	}
	412	while (len-- > 0) {
	413	cp = fcomplex.Abs(ap ) /dummy/;
	414	ap++;
	415	cp++;
	416	}
	417	}
	418	System.Threading.Interlocked.Decrement(ref workerCount);
	419	};
	420
	421	fixed ( fcomplex* arrAP = arrA)
	422	fixed ( float* retArrP = retArr) {
	423	for (; i < workItemCount - 1; i++) {
	424	Tuple<int, int, IntPtr, IntPtr, bool> range
	425	= new Tuple<int, int, IntPtr, IntPtr, bool>
	426	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	427	System.Threading.Interlocked.Increment(ref workerCount);
	428	ILThreadPool.QueueUserWorkItem(i,worker, range);
	429	}
	430	// the last (or may the only) chunk is done right here
	431	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	432	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	433
	434	ILThreadPool.Wait4Workers(ref workerCount);
	435	}
	436	return new ILRetArray<float>(retStorage);
	437	}
	438	}
	439	/// <summary>Magnitude of array elements</summary>
	440	/// <param name="A">Input array</param>
	441	/// <returns>Magnitude of array elements</returns>
	442	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	443	/// <para>The array returned will be a dense array.</para></remarks>
	444	public unsafe static ILRetArray<double> abs (ILInArray< complex > A) {
	445	using (ILScope.Enter(A)) {
	446	if (A.IsEmpty)
	447	return new ILRetArray<double>(A.Size);
	448	ILSize inDim = A.Size;
	449	complex[] arrA = A.GetArrayForRead();
	450	double [] retArr;
	451	int outLen = inDim.NumberOfElements;
	452	bool inplace = true;
	453
	454	if (true){
	455	retArr = ILMemoryPool.Pool.New<double>(outLen);
	456	inplace = false;
	457	}
	458	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	459	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	460	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	461	workItemLength = outLen / workItemCount;
	462	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	463	} else {
	464	workItemLength = outLen / 2;
	465	workItemCount = 2;
	466	}
	467	} else {
	468	workItemLength = outLen;
	469	workItemCount = 1;
	470	}
	471	ILDenseStorage<double> retStorage = new ILDenseStorage<double>(retArr, inDim);
	472
	473	Action<object> worker = data => {
	474	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	475
	476	double* cp = ((double*)range.Item4 + range.Item1);
	477	int len = range.Item2;
	478	if (range.Item5) {
	479	// inplace
	480	while (len > 20) {
	481	cp[0] = complex.Abs(cp[0] ) /dummy/;
	482	cp[1] = complex.Abs(cp[1] ) /dummy/;
	483	cp[2] = complex.Abs(cp[2] ) /dummy/;
	484	cp[3] = complex.Abs(cp[3] ) /dummy/;
	485	cp[4] = complex.Abs(cp[4] ) /dummy/;
	486	cp[5] = complex.Abs(cp[5] ) /dummy/;
	487	cp[6] = complex.Abs(cp[6] ) /dummy/;
	488	cp[7] = complex.Abs(cp[7] ) /dummy/;
	489	cp[8] = complex.Abs(cp[8] ) /dummy/;
	490	cp[9] = complex.Abs(cp[9] ) /dummy/;
	491	cp[10] = complex.Abs(cp[10] ) /dummy/;
	492	cp[11] = complex.Abs(cp[11] ) /dummy/;
	493	cp[12] = complex.Abs(cp[12] ) /dummy/;
	494	cp[13] = complex.Abs(cp[13] ) /dummy/;
	495	cp[14] = complex.Abs(cp[14] ) /dummy/;
	496	cp[15] = complex.Abs(cp[15] ) /dummy/;
	497	cp[16] = complex.Abs(cp[16] ) /dummy/;
	498	cp[17] = complex.Abs(cp[17] ) /dummy/;
	499	cp[18] = complex.Abs(cp[18] ) /dummy/;
	500	cp[19] = complex.Abs(cp[19] ) /dummy/;
	501	cp[20] = complex.Abs(cp[20] ) /dummy/;
	502	cp+=21; len -= 21;
	503	}
	504	while (len-- > 0) {
	505	cp = complex.Abs(cp ) /dummy/;
	506	cp++;
	507	}
	508	} else {
	509	complex* ap = ((complex*)range.Item3 + range.Item1);
	510	while (len > 20) {
	511	cp[0] = complex.Abs(ap[0] ) /dummy/;
	512	cp[1] = complex.Abs(ap[1] ) /dummy/;
	513	cp[2] = complex.Abs(ap[2] ) /dummy/;
	514	cp[3] = complex.Abs(ap[3] ) /dummy/;
	515	cp[4] = complex.Abs(ap[4] ) /dummy/;
	516	cp[5] = complex.Abs(ap[5] ) /dummy/;
	517	cp[6] = complex.Abs(ap[6] ) /dummy/;
	518	cp[7] = complex.Abs(ap[7] ) /dummy/;
	519	cp[8] = complex.Abs(ap[8] ) /dummy/;
	520	cp[9] = complex.Abs(ap[9] ) /dummy/;
	521	cp[10] = complex.Abs(ap[10] ) /dummy/;
	522	cp[11] = complex.Abs(ap[11] ) /dummy/;
	523	cp[12] = complex.Abs(ap[12] ) /dummy/;
	524	cp[13] = complex.Abs(ap[13] ) /dummy/;
	525	cp[14] = complex.Abs(ap[14] ) /dummy/;
	526	cp[15] = complex.Abs(ap[15] ) /dummy/;
	527	cp[16] = complex.Abs(ap[16] ) /dummy/;
	528	cp[17] = complex.Abs(ap[17] ) /dummy/;
	529	cp[18] = complex.Abs(ap[18] ) /dummy/;
	530	cp[19] = complex.Abs(ap[19] ) /dummy/;
	531	cp[20] = complex.Abs(ap[20] ) /dummy/;
	532	ap += 21;
	533	cp += 21;
	534	len -= 21;
	535	}
	536	while (len-- > 0) {
	537	cp = complex.Abs(ap ) /dummy/;
	538	ap++;
	539	cp++;
	540	}
	541	}
	542	System.Threading.Interlocked.Decrement(ref workerCount);
	543	};
	544
	545	fixed ( complex* arrAP = arrA)
	546	fixed ( double* retArrP = retArr) {
	547	for (; i < workItemCount - 1; i++) {
	548	Tuple<int, int, IntPtr, IntPtr, bool> range
	549	= new Tuple<int, int, IntPtr, IntPtr, bool>
	550	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	551	System.Threading.Interlocked.Increment(ref workerCount);
	552	ILThreadPool.QueueUserWorkItem(i,worker, range);
	553	}
	554	// the last (or may the only) chunk is done right here
	555	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	556	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	557
	558	ILThreadPool.Wait4Workers(ref workerCount);
	559	}
	560	return new ILRetArray<double>(retStorage);
	561	}
	562	}
	563	/// <summary>Absolute values of array elements</summary>
	564	/// <param name="A">Input array</param>
	565	/// <returns>Absolute values of array elements</returns>
	566	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	567	/// <para>The array returned will be a dense array.</para></remarks>
	568	public unsafe static ILRetArray<Int64> abs (ILInArray< Int64 > A) {
	569	using (ILScope.Enter(A)) {
	570	if (A.IsEmpty)
	571	return new ILRetArray<Int64>(A.Size);
	572	ILSize inDim = A.Size;
	573	Int64[] arrA = A.GetArrayForRead();
	574	Int64 [] retArr;
	575	int outLen = inDim.NumberOfElements;
	576	bool inplace = true;
	577
	578	if (!A.TryGetStorage4InplaceOp(out retArr)){
	579	retArr = ILMemoryPool.Pool.New<Int64>(outLen);
	580	inplace = false;
	581	}
	582	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	583	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	584	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	585	workItemLength = outLen / workItemCount;
	586	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	587	} else {
	588	workItemLength = outLen / 2;
	589	workItemCount = 2;
	590	}
	591	} else {
	592	workItemLength = outLen;
	593	workItemCount = 1;
	594	}
	595	ILDenseStorage<Int64> retStorage = new ILDenseStorage<Int64>(retArr, inDim);
	596
	597	Action<object> worker = data => {
	598	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	599
	600	Int64* cp = ((Int64*)range.Item4 + range.Item1);
	601	int len = range.Item2;
	602	if (range.Item5) {
	603	// inplace
	604	while (len > 20) {
	605	cp[0] = Math.Abs(cp[0] ) /dummy/;
	606	cp[1] = Math.Abs(cp[1] ) /dummy/;
	607	cp[2] = Math.Abs(cp[2] ) /dummy/;
	608	cp[3] = Math.Abs(cp[3] ) /dummy/;
	609	cp[4] = Math.Abs(cp[4] ) /dummy/;
	610	cp[5] = Math.Abs(cp[5] ) /dummy/;
	611	cp[6] = Math.Abs(cp[6] ) /dummy/;
	612	cp[7] = Math.Abs(cp[7] ) /dummy/;
	613	cp[8] = Math.Abs(cp[8] ) /dummy/;
	614	cp[9] = Math.Abs(cp[9] ) /dummy/;
	615	cp[10] = Math.Abs(cp[10] ) /dummy/;
	616	cp[11] = Math.Abs(cp[11] ) /dummy/;
	617	cp[12] = Math.Abs(cp[12] ) /dummy/;
	618	cp[13] = Math.Abs(cp[13] ) /dummy/;
	619	cp[14] = Math.Abs(cp[14] ) /dummy/;
	620	cp[15] = Math.Abs(cp[15] ) /dummy/;
	621	cp[16] = Math.Abs(cp[16] ) /dummy/;
	622	cp[17] = Math.Abs(cp[17] ) /dummy/;
	623	cp[18] = Math.Abs(cp[18] ) /dummy/;
	624	cp[19] = Math.Abs(cp[19] ) /dummy/;
	625	cp[20] = Math.Abs(cp[20] ) /dummy/;
	626	cp+=21; len -= 21;
	627	}
	628	while (len-- > 0) {
	629	cp = Math.Abs(cp ) /dummy/;
	630	cp++;
	631	}
	632	} else {
	633	Int64* ap = ((Int64*)range.Item3 + range.Item1);
	634	while (len > 20) {
	635	cp[0] = Math.Abs(ap[0] ) /dummy/;
	636	cp[1] = Math.Abs(ap[1] ) /dummy/;
	637	cp[2] = Math.Abs(ap[2] ) /dummy/;
	638	cp[3] = Math.Abs(ap[3] ) /dummy/;
	639	cp[4] = Math.Abs(ap[4] ) /dummy/;
	640	cp[5] = Math.Abs(ap[5] ) /dummy/;
	641	cp[6] = Math.Abs(ap[6] ) /dummy/;
	642	cp[7] = Math.Abs(ap[7] ) /dummy/;
	643	cp[8] = Math.Abs(ap[8] ) /dummy/;
	644	cp[9] = Math.Abs(ap[9] ) /dummy/;
	645	cp[10] = Math.Abs(ap[10] ) /dummy/;
	646	cp[11] = Math.Abs(ap[11] ) /dummy/;
	647	cp[12] = Math.Abs(ap[12] ) /dummy/;
	648	cp[13] = Math.Abs(ap[13] ) /dummy/;
	649	cp[14] = Math.Abs(ap[14] ) /dummy/;
	650	cp[15] = Math.Abs(ap[15] ) /dummy/;
	651	cp[16] = Math.Abs(ap[16] ) /dummy/;
	652	cp[17] = Math.Abs(ap[17] ) /dummy/;
	653	cp[18] = Math.Abs(ap[18] ) /dummy/;
	654	cp[19] = Math.Abs(ap[19] ) /dummy/;
	655	cp[20] = Math.Abs(ap[20] ) /dummy/;
	656	ap += 21;
	657	cp += 21;
	658	len -= 21;
	659	}
	660	while (len-- > 0) {
	661	cp = Math.Abs(ap ) /dummy/;
	662	ap++;
	663	cp++;
	664	}
	665	}
	666	System.Threading.Interlocked.Decrement(ref workerCount);
	667	};
	668
	669	fixed ( Int64* arrAP = arrA)
	670	fixed ( Int64* retArrP = retArr) {
	671	for (; i < workItemCount - 1; i++) {
	672	Tuple<int, int, IntPtr, IntPtr, bool> range
	673	= new Tuple<int, int, IntPtr, IntPtr, bool>
	674	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	675	System.Threading.Interlocked.Increment(ref workerCount);
	676	ILThreadPool.QueueUserWorkItem(i,worker, range);
	677	}
	678	// the last (or may the only) chunk is done right here
	679	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	680	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	681
	682	ILThreadPool.Wait4Workers(ref workerCount);
	683	}
	684	return new ILRetArray<Int64>(retStorage);
	685	}
	686	}
	687	/// <summary>Absolute values of array elements</summary>
	688	/// <param name="A">Input array</param>
	689	/// <returns>Absolute values of array elements</returns>
	690	/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
	691	/// <para>The array returned will be a dense array.</para></remarks>
	692	public unsafe static ILRetArray<Int32> abs (ILInArray< Int32 > A) {
	693	using (ILScope.Enter(A)) {
	694	if (A.IsEmpty)
	695	return new ILRetArray<Int32>(A.Size);
	696	ILSize inDim = A.Size;
	697	Int32[] arrA = A.GetArrayForRead();
	698	Int32 [] retArr;
	699	int outLen = inDim.NumberOfElements;
	700	bool inplace = true;
	701
	702	if (!A.TryGetStorage4InplaceOp(out retArr)){
	703	retArr = ILMemoryPool.Pool.New<Int32>(outLen);
	704	inplace = false;
	705	}
	706	int i = 0, workItemCount = Settings.s_maxNumberThreads, workItemLength, workerCount = 1;
	707	if (Settings.s_maxNumberThreads > 1 && outLen / 2 > Settings.s_minParallelElement1Count) {
	708	if (outLen / workItemCount > Settings.s_minParallelElement1Count) {
	709	workItemLength = outLen / workItemCount;
	710	//workItemLength = (int)((double)outLen / workItemCount * 1.05);
	711	} else {
	712	workItemLength = outLen / 2;
	713	workItemCount = 2;
	714	}
	715	} else {
	716	workItemLength = outLen;
	717	workItemCount = 1;
	718	}
	719	ILDenseStorage<Int32> retStorage = new ILDenseStorage<Int32>(retArr, inDim);
	720
	721	Action<object> worker = data => {
	722	Tuple<int, int, IntPtr, IntPtr, bool> range = (Tuple<int, int, IntPtr, IntPtr, bool>)data;
	723
	724	Int32* cp = ((Int32*)range.Item4 + range.Item1);
	725	int len = range.Item2;
	726	if (range.Item5) {
	727	// inplace
	728	while (len > 20) {
	729	cp[0] = Math.Abs(cp[0] ) /dummy/;
	730	cp[1] = Math.Abs(cp[1] ) /dummy/;
	731	cp[2] = Math.Abs(cp[2] ) /dummy/;
	732	cp[3] = Math.Abs(cp[3] ) /dummy/;
	733	cp[4] = Math.Abs(cp[4] ) /dummy/;
	734	cp[5] = Math.Abs(cp[5] ) /dummy/;
	735	cp[6] = Math.Abs(cp[6] ) /dummy/;
	736	cp[7] = Math.Abs(cp[7] ) /dummy/;
	737	cp[8] = Math.Abs(cp[8] ) /dummy/;
	738	cp[9] = Math.Abs(cp[9] ) /dummy/;
	739	cp[10] = Math.Abs(cp[10] ) /dummy/;
	740	cp[11] = Math.Abs(cp[11] ) /dummy/;
	741	cp[12] = Math.Abs(cp[12] ) /dummy/;
	742	cp[13] = Math.Abs(cp[13] ) /dummy/;
	743	cp[14] = Math.Abs(cp[14] ) /dummy/;
	744	cp[15] = Math.Abs(cp[15] ) /dummy/;
	745	cp[16] = Math.Abs(cp[16] ) /dummy/;
	746	cp[17] = Math.Abs(cp[17] ) /dummy/;
	747	cp[18] = Math.Abs(cp[18] ) /dummy/;
	748	cp[19] = Math.Abs(cp[19] ) /dummy/;
	749	cp[20] = Math.Abs(cp[20] ) /dummy/;
	750	cp+=21; len -= 21;
	751	}
	752	while (len-- > 0) {
	753	cp = Math.Abs(cp ) /dummy/;
	754	cp++;
	755	}
	756	} else {
	757	Int32* ap = ((Int32*)range.Item3 + range.Item1);
	758	while (len > 20) {
	759	cp[0] = Math.Abs(ap[0] ) /dummy/;
	760	cp[1] = Math.Abs(ap[1] ) /dummy/;
	761	cp[2] = Math.Abs(ap[2] ) /dummy/;
	762	cp[3] = Math.Abs(ap[3] ) /dummy/;
	763	cp[4] = Math.Abs(ap[4] ) /dummy/;
	764	cp[5] = Math.Abs(ap[5] ) /dummy/;
	765	cp[6] = Math.Abs(ap[6] ) /dummy/;
	766	cp[7] = Math.Abs(ap[7] ) /dummy/;
	767	cp[8] = Math.Abs(ap[8] ) /dummy/;
	768	cp[9] = Math.Abs(ap[9] ) /dummy/;
	769	cp[10] = Math.Abs(ap[10] ) /dummy/;
	770	cp[11] = Math.Abs(ap[11] ) /dummy/;
	771	cp[12] = Math.Abs(ap[12] ) /dummy/;
	772	cp[13] = Math.Abs(ap[13] ) /dummy/;
	773	cp[14] = Math.Abs(ap[14] ) /dummy/;
	774	cp[15] = Math.Abs(ap[15] ) /dummy/;
	775	cp[16] = Math.Abs(ap[16] ) /dummy/;
	776	cp[17] = Math.Abs(ap[17] ) /dummy/;
	777	cp[18] = Math.Abs(ap[18] ) /dummy/;
	778	cp[19] = Math.Abs(ap[19] ) /dummy/;
	779	cp[20] = Math.Abs(ap[20] ) /dummy/;
	780	ap += 21;
	781	cp += 21;
	782	len -= 21;
	783	}
	784	while (len-- > 0) {
	785	cp = Math.Abs(ap ) /dummy/;
	786	ap++;
	787	cp++;
	788	}
	789	}
	790	System.Threading.Interlocked.Decrement(ref workerCount);
	791	};
	792
	793	fixed ( Int32* arrAP = arrA)
	794	fixed ( Int32* retArrP = retArr) {
	795	for (; i < workItemCount - 1; i++) {
	796	Tuple<int, int, IntPtr, IntPtr, bool> range
	797	= new Tuple<int, int, IntPtr, IntPtr, bool>
	798	(i * workItemLength, workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace);
	799	System.Threading.Interlocked.Increment(ref workerCount);
	800	ILThreadPool.QueueUserWorkItem(i,worker, range);
	801	}
	802	// the last (or may the only) chunk is done right here
	803	worker(new Tuple<int, int, IntPtr, IntPtr, bool>
	804	(i * workItemLength, outLen - i * workItemLength, (IntPtr)arrAP, (IntPtr)retArrP, inplace));
	805
	806	ILThreadPool.Wait4Workers(ref workerCount);
	807	}
	808	return new ILRetArray<Int32>(retStorage);
	809	}
	810	}
	811
	812	#endregion HYCALPER AUTO GENERATED CODE
	813
	814	}
	815	}

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

Download in other formats:

Update cookies preferences