Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Functions/builtin/Sum.cs @ 10355

Visit:

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

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

Download in other formats:

Update cookies preferences