Context Navigation

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

Visit:

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

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

Download in other formats:

Update cookies preferences