Context Navigation

source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Storage/ILDenseStorage.cs @ 12064

Visit:

Last change on this file since 12064 was 9102, checked in by gkronber, 12 years ago
#1967: ILNumerics source for experimentation
File size: 146.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 System.IO;
	44	using System.Runtime.Serialization;
	45	using System.Runtime.CompilerServices;
	46	using System.Numerics;
	47	using ILNumerics.Misc;
	48	using ILNumerics.Data;
	49	using ILNumerics.Exceptions;
	50	using System.Linq.Expressions;
	51
	52	namespace ILNumerics.Storage {
	53
	54	/// <summary>
	55	/// The class realizes an internal storage wrapper. It stores the internal data array
	56	/// and the dimension specifications for both: ILRetArray and ILDenseStorage (reference and solid).
	57	/// </summary>
	58	[System.Diagnostics.DebuggerTypeProxy(typeof(ILNumerics.Misc.ILArrayDebuggerProxy<>))]
	59	[System.Diagnostics.DebuggerDisplay("{ShortInfo(),nq}")]
	60	[Serializable]
	61	internal partial class ILDenseStorage<ElementType> : ILStorage<ElementType> {
	62
	63	#region attributes
	64	/// <summary>
	65	/// Internal storage object. Contains the final System.Array storage and a reference counter.
	66	/// </summary>
	67	[System.Diagnostics.DebuggerBrowsable(System.Diagnostics.DebuggerBrowsableState.Never)]
	68	protected ILCountableArray<ElementType> m_data;
	69	#endregion
	70
	71	#region properties
	72
	73	/// <summary>
	74	/// number of storages referencing the current data array
	75	/// </summary>
	76	internal int ReferenceCount {
	77	get {
	78	return m_data.ReferenceCount;
	79	}
	80	}
	81
	82	/// <summary>
	83	/// Determine, if this storage has already been disposed.
	84	/// </summary>
	85	internal override bool IsDisposed {
	86	get {
	87	return m_data == null;
	88	}
	89	}
	90	protected ILCountableArray<ElementType> Data {
	91	get {
	92	return m_data;
	93	}
	94	set {
	95	ILCountableArray<ElementType> old = m_data;
	96	m_data = value;
	97	m_data.IncreaseReference();
	98	if (old != null)
	99	old.DecreaseReference();
	100	}
	101	}
	102	/// <summary>
	103	/// Get minimum and maximum value of all elements - if these exist.
	104	/// </summary>
	105	/// <param name="minValue">Output: minimum value.</param>
	106	/// <param name="maxValue">Output: maximum value.</param>
	107	/// <returns>True if the limits exists and could be computed, false otherwise.</returns>
	108	/// <remarks>Empty arrays will return false. The output parameter will be default(type).</remarks>
	109	internal override bool GetLimits(out ElementType minValue, out ElementType maxValue) {
	110	return GetLimits(out minValue, out maxValue, true);
	111	}
	112	/// <summary>
	113	/// Get minimum and maximum value of all elements - if existing
	114	/// </summary>
	115	/// <param name="minValue">Output: minimum value.</param>
	116	/// <param name="maxValue">Output: maximum value.</param>
	117	/// <param name="includeInfNaNs">true: recognize Inf, NaN values; false: ignore those values</param>
	118	/// <returns>True if the limits exists and could be computed, false otherwise.</returns>
	119	/// <remarks>Empty arrays will return false. The output parameter will be default(ElementType) then.</remarks>
	120	internal override bool GetLimits(out ElementType minValue, out ElementType maxValue, bool includeInfNaNs) {
	121	minValue = default(ElementType);
	122	maxValue = default(ElementType);
	123	if (m_size.NumberOfElements == 0)
	124	return false;
	125	if (false) {
	126
	127
	128	} else if (this is ILDenseStorage<double> ) {
	129	double [] data = ( double [])(object) GetArrayForRead();
	130	double curVal;
	131	double curMin = Double.PositiveInfinity ;
	132	double curMax = Double.NegativeInfinity ;
	133	int curMinInd = 0;
	134	int curMaxInd = 0;
	135	int len = m_size.NumberOfElements;
	136
	137	for (int i = 0; i < len; i++) {
	138	curVal = data[i];
	139
	140	if (double.IsInfinity(curVal)) continue;
	141	if (curVal < curMin) {
	142	curMin = curVal;
	143	curMinInd = i;
	144	}
	145	if (curVal > curMax) {
	146	curMax = curVal;
	147	curMaxInd = i;
	148	}
	149	}
	150	maxValue = m_data.Data[curMaxInd];
	151	minValue = m_data.Data[curMinInd];
	152	return (curMax > Double.NegativeInfinity \|\| curMin < Double.PositiveInfinity );
	153
	154	#region HYCALPER AUTO GENERATED CODE
	155
	156
	157	} else if (this is ILDenseStorage<fcomplex> ) {
	158	fcomplex [] data = ( fcomplex [])(object) GetArrayForRead();
	159	fcomplex curVal;
	160	fcomplex curMin = new fcomplex(float.PositiveInfinity,float.PositiveInfinity) ;
	161	fcomplex curMax = new fcomplex(float.NegativeInfinity,float.NegativeInfinity) ;
	162	int curMinInd = 0;
	163	int curMaxInd = 0;
	164	int len = m_size.NumberOfElements;
	165
	166	for (int i = 0; i < len; i++) {
	167	curVal = data[i];
	168	if (fcomplex.IsInfinity(curVal)) continue;
	169	if (curVal < curMin) {
	170	curMin = curVal;
	171	curMinInd = i;
	172	}
	173	if (curVal > curMax) {
	174	curMax = curVal;
	175	curMaxInd = i;
	176	}
	177	}
	178	maxValue = m_data.Data[curMaxInd];
	179	minValue = m_data.Data[curMinInd];
	180	return (curMax > new fcomplex(float.NegativeInfinity,float.NegativeInfinity) \|\| curMin < new fcomplex(float.NegativeInfinity,float.NegativeInfinity) );
	181
	182	} else if (this is ILDenseStorage<complex> ) {
	183	complex [] data = ( complex [])(object) GetArrayForRead();
	184	complex curVal;
	185	complex curMin = new complex(Double.PositiveInfinity,Double.PositiveInfinity) ;
	186	complex curMax = new complex(Double.NegativeInfinity,Double.NegativeInfinity) ;
	187	int curMinInd = 0;
	188	int curMaxInd = 0;
	189	int len = m_size.NumberOfElements;
	190
	191	for (int i = 0; i < len; i++) {
	192	curVal = data[i];
	193	if (complex.IsInfinity(curVal)) continue;
	194	if (curVal < curMin) {
	195	curMin = curVal;
	196	curMinInd = i;
	197	}
	198	if (curVal > curMax) {
	199	curMax = curVal;
	200	curMaxInd = i;
	201	}
	202	}
	203	maxValue = m_data.Data[curMaxInd];
	204	minValue = m_data.Data[curMinInd];
	205	return (curMax > new complex(Double.NegativeInfinity,Double.NegativeInfinity) \|\| curMin < new complex(Double.NegativeInfinity,Double.NegativeInfinity) );
	206
	207	} else if (this is ILDenseStorage<byte> ) {
	208	byte [] data = ( byte [])(object) GetArrayForRead();
	209	byte curVal;
	210	byte curMin = Byte.MaxValue ;
	211	byte curMax = Byte.MinValue ;
	212	int curMinInd = 0;
	213	int curMaxInd = 0;
	214	int len = m_size.NumberOfElements;
	215
	216	for (int i = 0; i < len; i++) {
	217	curVal = data[i];
	218
	219	if (curVal < curMin) {
	220	curMin = curVal;
	221	curMinInd = i;
	222	}
	223	if (curVal > curMax) {
	224	curMax = curVal;
	225	curMaxInd = i;
	226	}
	227	}
	228	maxValue = m_data.Data[curMaxInd];
	229	minValue = m_data.Data[curMinInd];
	230	return (curMax > Byte.MinValue \|\| curMin < Byte.MinValue );
	231
	232	} else if (this is ILDenseStorage<Int64> ) {
	233	Int64 [] data = ( Int64 [])(object) GetArrayForRead();
	234	Int64 curVal;
	235	Int64 curMin = Int64.MaxValue ;
	236	Int64 curMax = Int64.MinValue ;
	237	int curMinInd = 0;
	238	int curMaxInd = 0;
	239	int len = m_size.NumberOfElements;
	240
	241	for (int i = 0; i < len; i++) {
	242	curVal = data[i];
	243
	244	if (curVal < curMin) {
	245	curMin = curVal;
	246	curMinInd = i;
	247	}
	248	if (curVal > curMax) {
	249	curMax = curVal;
	250	curMaxInd = i;
	251	}
	252	}
	253	maxValue = m_data.Data[curMaxInd];
	254	minValue = m_data.Data[curMinInd];
	255	return (curMax > Int64.MinValue \|\| curMin < Int64.MinValue );
	256
	257	} else if (this is ILDenseStorage<Int32> ) {
	258	Int32 [] data = ( Int32 [])(object) GetArrayForRead();
	259	Int32 curVal;
	260	Int32 curMin = Int32.MaxValue ;
	261	Int32 curMax = Int32.MinValue ;
	262	int curMinInd = 0;
	263	int curMaxInd = 0;
	264	int len = m_size.NumberOfElements;
	265
	266	for (int i = 0; i < len; i++) {
	267	curVal = data[i];
	268
	269	if (curVal < curMin) {
	270	curMin = curVal;
	271	curMinInd = i;
	272	}
	273	if (curVal > curMax) {
	274	curMax = curVal;
	275	curMaxInd = i;
	276	}
	277	}
	278	maxValue = m_data.Data[curMaxInd];
	279	minValue = m_data.Data[curMinInd];
	280	return (curMax > Int32.MinValue \|\| curMin < Int32.MinValue );
	281
	282	} else if (this is ILDenseStorage<float> ) {
	283	float [] data = ( float [])(object) GetArrayForRead();
	284	float curVal;
	285	float curMin = float.PositiveInfinity ;
	286	float curMax = float.NegativeInfinity ;
	287	int curMinInd = 0;
	288	int curMaxInd = 0;
	289	int len = m_size.NumberOfElements;
	290
	291	for (int i = 0; i < len; i++) {
	292	curVal = data[i];
	293	if(float.IsInfinity(curVal)) continue;
	294	if (curVal < curMin) {
	295	curMin = curVal;
	296	curMinInd = i;
	297	}
	298	if (curVal > curMax) {
	299	curMax = curVal;
	300	curMaxInd = i;
	301	}
	302	}
	303	maxValue = m_data.Data[curMaxInd];
	304	minValue = m_data.Data[curMinInd];
	305	return (curMax > float.NegativeInfinity \|\| curMin < float.NegativeInfinity );
	306
	307	#endregion HYCALPER AUTO GENERATED CODE
	308	} else if ((typeof(ElementType) is IComparable<ElementType>)) {
	309	ElementType[] tmpArr = GetArrayForRead();
	310	for (int i = 0; i < m_size.NumberOfElements; i++) {
	311	ElementType val = tmpArr[i];
	312	if (((IComparable<ElementType>)val).CompareTo(minValue) < 0)
	313	minValue = val;
	314	if (((IComparable<ElementType>)val).CompareTo(minValue) > 0)
	315	maxValue = val;
	316	}
	317	return true;
	318	}
	319	return false;
	320	}
	321	#endregion
	322
	323	#region overriding object.ToString(), Equals()
	324	/// <summary>
	325	/// Write information about the ILDenseStorage to string.
	326	/// </summary>
	327	/// <returns>String containing general information about the current instance of
	328	/// ILDenseStorage and the formatted elements' values.</returns>
	329	/// <remarks>If the number of elements exceeds a certain amount, the display will be abreviated.</remarks>
	330	public override string ToString() {
	331	return ValuesToString(0).ToString();
	332	}
	333	/// <summary>
	334	/// print formated values to string
	335	/// </summary>
	336	/// <param name="maxLength">Maximum number of characters per line. 0: no limit</param>
	337	/// <returns>StringBuilder object filled with formated values.</returns>
	338	internal override StringBuilder ValuesToString(int maxLength) {
	339	StringBuilder s = new StringBuilder();
	340	if (maxLength <= 0) maxLength = int.MaxValue;
	341	//if (m_dimensions.NumberOfElements > 100000) {
	342	// s.Append(String.Format("({0})", m_dimensions.ToString()));
	343	// return s;
	344	//}
	345	if (m_size.NumberOfElements < 1)
	346	return new StringBuilder("(Empty)");
	347	int[] acc = new int[m_size.NumberOfDimensions];
	348	int d;
	349	String sElement;
	350	int elemLength = 10;
	351	//string format = "{0,20: E13;-E13; 0.0 } ";
	352	int curLineLength = 0, curRowsCount = 0;
	353	int maxRows = (maxLength == int.MaxValue) ? int.MaxValue : 500; // limit data rows in debugger view
	354	if (false) {
	355
	356
	357	} else if (this.Data.Data.GetType() == typeof( double [] )) {
	358	#region
	359	double element;
	360	double [] elements = (this.Data.Data as double []);
	361	elemLength = 10 ;
	362
	363	double scaling = getScalingForPrint();
	364	elemLength++;
	365	while (acc[m_size.NumberOfDimensions - 1] <
	366	m_size[m_size.NumberOfDimensions - 1]) {
	367	// show only two first dimensions at the same time ...
	368	// print header
	369	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	370	if (s.Length > 0) s.Append(Environment.NewLine);
	371	s.Append("(:,:");
	372	for (d = 2; d < m_size.NumberOfDimensions; d++)
	373	s.Append(String.Format(",{0}", acc[d]));
	374	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	375	}
	376	// show this for 2 leading dimensions
	377	for (int d0 = 0; d0 < m_size[0]; d0++) {
	378	if (++curRowsCount > maxRows) {
	379	s.Append(Environment.NewLine + "( ... more rows exist)");
	380	return s;
	381	}
	382	if (s.Length > 0) s.Append(Environment.NewLine);
	383	acc[0] = d0; curLineLength = 0;
	384	for (int d1 = 0; d1 < m_size[1]; d1++) {
	385	acc[1] = d1;
	386	element = elements [m_size.IndexFromArray(acc)];
	387	if (!Object.ReferenceEquals(element,null)) {
	388
	389	sElement = String.Format ((scaling == 1 && (int)element == element) ? "{0} " : "{0:f5} ", element / scaling).PadLeft(elemLength);
	390	} else {
	391	sElement = "(null)".PadLeft(elemLength);
	392	}
	393	curLineLength += sElement.Length;
	394	if (curLineLength > maxLength - " ...".Length) {
	395	s.Append(" ...");
	396	break;
	397	} else {
	398	s.Append(sElement);
	399	}
	400	}
	401	}
	402	// increase higher dimension
	403	d = 2;
	404	while (d <= m_size.NumberOfDimensions - 1) {
	405	acc[d]++;
	406	if (acc[d] < m_size[d]) break;
	407	acc[d] = 0;
	408	d++;
	409	}
	410	if (d >= m_size.NumberOfDimensions) break;
	411	}
	412	#endregion
	413
	414	#region HYCALPER AUTO GENERATED CODE
	415
	416
	417	} else if (this.Data.Data.GetType() == typeof( float [] )) {
	418	#region
	419	float element;
	420	float [] elements = (this.Data.Data as float []);
	421	elemLength = 5 ;
	422	float scaling = (float)getScalingForPrint();
	423	elemLength++;
	424	while (acc[m_size.NumberOfDimensions - 1] <
	425	m_size[m_size.NumberOfDimensions - 1]) {
	426	// show only two first dimensions at the same time ...
	427	// print header
	428	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	429	if (s.Length > 0) s.Append(Environment.NewLine);
	430	s.Append("(:,:");
	431	for (d = 2; d < m_size.NumberOfDimensions; d++)
	432	s.Append(String.Format(",{0}", acc[d]));
	433	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	434	}
	435	// show this for 2 leading dimensions
	436	for (int d0 = 0; d0 < m_size[0]; d0++) {
	437	if (++curRowsCount > maxRows) {
	438	s.Append(Environment.NewLine + "( ... more rows exist)");
	439	return s;
	440	}
	441	if (s.Length > 0) s.Append(Environment.NewLine);
	442	acc[0] = d0; curLineLength = 0;
	443	for (int d1 = 0; d1 < m_size[1]; d1++) {
	444	acc[1] = d1;
	445	element = elements [m_size.IndexFromArray(acc)];
	446	if (!Object.ReferenceEquals(element,null)) {
	447	sElement = String.Format ("{0:f5} ", element / scaling).PadLeft(elemLength);
	448	} else {
	449	sElement = "(null)".PadLeft(elemLength);
	450	}
	451	curLineLength += sElement.Length;
	452	if (curLineLength > maxLength - " ...".Length) {
	453	s.Append(" ...");
	454	break;
	455	} else {
	456	s.Append(sElement);
	457	}
	458	}
	459	}
	460	// increase higher dimension
	461	d = 2;
	462	while (d <= m_size.NumberOfDimensions - 1) {
	463	acc[d]++;
	464	if (acc[d] < m_size[d]) break;
	465	acc[d] = 0;
	466	d++;
	467	}
	468	if (d >= m_size.NumberOfDimensions) break;
	469	}
	470	#endregion
	471
	472	} else if (this.Data.Data.GetType() == typeof( fcomplex [] )) {
	473	#region
	474	fcomplex element;
	475	fcomplex [] elements = (this.Data.Data as fcomplex []);
	476	elemLength = 24 ;
	477	float scaling = (float)getScalingForPrint();
	478	elemLength++;
	479	while (acc[m_size.NumberOfDimensions - 1] <
	480	m_size[m_size.NumberOfDimensions - 1]) {
	481	// show only two first dimensions at the same time ...
	482	// print header
	483	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	484	if (s.Length > 0) s.Append(Environment.NewLine);
	485	s.Append("(:,:");
	486	for (d = 2; d < m_size.NumberOfDimensions; d++)
	487	s.Append(String.Format(",{0}", acc[d]));
	488	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	489	}
	490	// show this for 2 leading dimensions
	491	for (int d0 = 0; d0 < m_size[0]; d0++) {
	492	if (++curRowsCount > maxRows) {
	493	s.Append(Environment.NewLine + "( ... more rows exist)");
	494	return s;
	495	}
	496	if (s.Length > 0) s.Append(Environment.NewLine);
	497	acc[0] = d0; curLineLength = 0;
	498	for (int d1 = 0; d1 < m_size[1]; d1++) {
	499	acc[1] = d1;
	500	element = elements [m_size.IndexFromArray(acc)];
	501	if (!Object.ReferenceEquals(element,null)) {
	502	sElement = String.Format ("{0} ", (element / scaling).ToString(5)).PadLeft(elemLength);
	503	} else {
	504	sElement = "(null)".PadLeft(elemLength);
	505	}
	506	curLineLength += sElement.Length;
	507	if (curLineLength > maxLength - " ...".Length) {
	508	s.Append(" ...");
	509	break;
	510	} else {
	511	s.Append(sElement);
	512	}
	513	}
	514	}
	515	// increase higher dimension
	516	d = 2;
	517	while (d <= m_size.NumberOfDimensions - 1) {
	518	acc[d]++;
	519	if (acc[d] < m_size[d]) break;
	520	acc[d] = 0;
	521	d++;
	522	}
	523	if (d >= m_size.NumberOfDimensions) break;
	524	}
	525	#endregion
	526
	527	} else if (this.Data.Data.GetType() == typeof( complex [] )) {
	528	#region
	529	complex element;
	530	complex [] elements = (this.Data.Data as complex []);
	531	elemLength = 36 ;
	532	double scaling = getScalingForPrint();
	533	elemLength++;
	534	while (acc[m_size.NumberOfDimensions - 1] <
	535	m_size[m_size.NumberOfDimensions - 1]) {
	536	// show only two first dimensions at the same time ...
	537	// print header
	538	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	539	if (s.Length > 0) s.Append(Environment.NewLine);
	540	s.Append("(:,:");
	541	for (d = 2; d < m_size.NumberOfDimensions; d++)
	542	s.Append(String.Format(",{0}", acc[d]));
	543	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	544	}
	545	// show this for 2 leading dimensions
	546	for (int d0 = 0; d0 < m_size[0]; d0++) {
	547	if (++curRowsCount > maxRows) {
	548	s.Append(Environment.NewLine + "( ... more rows exist)");
	549	return s;
	550	}
	551	if (s.Length > 0) s.Append(Environment.NewLine);
	552	acc[0] = d0; curLineLength = 0;
	553	for (int d1 = 0; d1 < m_size[1]; d1++) {
	554	acc[1] = d1;
	555	element = elements [m_size.IndexFromArray(acc)];
	556	if (!Object.ReferenceEquals(element,null)) {
	557	sElement = String.Format ("{0} ", (element / scaling).ToString(5)).PadLeft(elemLength);
	558	} else {
	559	sElement = "(null)".PadLeft(elemLength);
	560	}
	561	curLineLength += sElement.Length;
	562	if (curLineLength > maxLength - " ...".Length) {
	563	s.Append(" ...");
	564	break;
	565	} else {
	566	s.Append(sElement);
	567	}
	568	}
	569	}
	570	// increase higher dimension
	571	d = 2;
	572	while (d <= m_size.NumberOfDimensions - 1) {
	573	acc[d]++;
	574	if (acc[d] < m_size[d]) break;
	575	acc[d] = 0;
	576	d++;
	577	}
	578	if (d >= m_size.NumberOfDimensions) break;
	579	}
	580	#endregion
	581
	582	} else if (this.Data.Data.GetType() == typeof( Complex [] )) {
	583	#region
	584	Complex element;
	585	Complex [] elements = (this.Data.Data as Complex []);
	586	elemLength = 36 ;
	587	double scaling = getScalingForPrint();
	588	elemLength++;
	589	while (acc[m_size.NumberOfDimensions - 1] <
	590	m_size[m_size.NumberOfDimensions - 1]) {
	591	// show only two first dimensions at the same time ...
	592	// print header
	593	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	594	if (s.Length > 0) s.Append(Environment.NewLine);
	595	s.Append("(:,:");
	596	for (d = 2; d < m_size.NumberOfDimensions; d++)
	597	s.Append(String.Format(",{0}", acc[d]));
	598	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	599	}
	600	// show this for 2 leading dimensions
	601	for (int d0 = 0; d0 < m_size[0]; d0++) {
	602	if (++curRowsCount > maxRows) {
	603	s.Append(Environment.NewLine + "( ... more rows exist)");
	604	return s;
	605	}
	606	if (s.Length > 0) s.Append(Environment.NewLine);
	607	acc[0] = d0; curLineLength = 0;
	608	for (int d1 = 0; d1 < m_size[1]; d1++) {
	609	acc[1] = d1;
	610	element = elements [m_size.IndexFromArray(acc)];
	611	if (!Object.ReferenceEquals(element,null)) {
	612	sElement = String.Format ("{0} ", ComplexHelper(element / scaling,5)).PadLeft(elemLength);
	613	} else {
	614	sElement = "(null)".PadLeft(elemLength);
	615	}
	616	curLineLength += sElement.Length;
	617	if (curLineLength > maxLength - " ...".Length) {
	618	s.Append(" ...");
	619	break;
	620	} else {
	621	s.Append(sElement);
	622	}
	623	}
	624	}
	625	// increase higher dimension
	626	d = 2;
	627	while (d <= m_size.NumberOfDimensions - 1) {
	628	acc[d]++;
	629	if (acc[d] < m_size[d]) break;
	630	acc[d] = 0;
	631	d++;
	632	}
	633	if (d >= m_size.NumberOfDimensions) break;
	634	}
	635	#endregion
	636
	637	} else if (this.Data.Data.GetType() == typeof( byte [] )) {
	638	#region
	639	byte element;
	640	byte [] elements = (this.Data.Data as byte []);
	641	elemLength = 3 ;
	642	double scaling = 1.0;
	643	elemLength++;
	644	while (acc[m_size.NumberOfDimensions - 1] <
	645	m_size[m_size.NumberOfDimensions - 1]) {
	646	// show only two first dimensions at the same time ...
	647	// print header
	648	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	649	if (s.Length > 0) s.Append(Environment.NewLine);
	650	s.Append("(:,:");
	651	for (d = 2; d < m_size.NumberOfDimensions; d++)
	652	s.Append(String.Format(",{0}", acc[d]));
	653	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	654	}
	655	// show this for 2 leading dimensions
	656	for (int d0 = 0; d0 < m_size[0]; d0++) {
	657	if (++curRowsCount > maxRows) {
	658	s.Append(Environment.NewLine + "( ... more rows exist)");
	659	return s;
	660	}
	661	if (s.Length > 0) s.Append(Environment.NewLine);
	662	acc[0] = d0; curLineLength = 0;
	663	for (int d1 = 0; d1 < m_size[1]; d1++) {
	664	acc[1] = d1;
	665	element = elements [m_size.IndexFromArray(acc)];
	666	if (!Object.ReferenceEquals(element,null)) {
	667	sElement = String.Format ("{0,3:G} ", element).PadLeft(elemLength);
	668	} else {
	669	sElement = "(null)".PadLeft(elemLength);
	670	}
	671	curLineLength += sElement.Length;
	672	if (curLineLength > maxLength - " ...".Length) {
	673	s.Append(" ...");
	674	break;
	675	} else {
	676	s.Append(sElement);
	677	}
	678	}
	679	}
	680	// increase higher dimension
	681	d = 2;
	682	while (d <= m_size.NumberOfDimensions - 1) {
	683	acc[d]++;
	684	if (acc[d] < m_size[d]) break;
	685	acc[d] = 0;
	686	d++;
	687	}
	688	if (d >= m_size.NumberOfDimensions) break;
	689	}
	690	#endregion
	691
	692	} else if (this.Data.Data.GetType() == typeof( char [] )) {
	693	#region
	694	char element;
	695	char [] elements = (this.Data.Data as char []);
	696	elemLength = 3 ;
	697	double scaling = 1.0;
	698	elemLength++;
	699	while (acc[m_size.NumberOfDimensions - 1] <
	700	m_size[m_size.NumberOfDimensions - 1]) {
	701	// show only two first dimensions at the same time ...
	702	// print header
	703	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	704	if (s.Length > 0) s.Append(Environment.NewLine);
	705	s.Append("(:,:");
	706	for (d = 2; d < m_size.NumberOfDimensions; d++)
	707	s.Append(String.Format(",{0}", acc[d]));
	708	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	709	}
	710	// show this for 2 leading dimensions
	711	for (int d0 = 0; d0 < m_size[0]; d0++) {
	712	if (++curRowsCount > maxRows) {
	713	s.Append(Environment.NewLine + "( ... more rows exist)");
	714	return s;
	715	}
	716	if (s.Length > 0) s.Append(Environment.NewLine);
	717	acc[0] = d0; curLineLength = 0;
	718	for (int d1 = 0; d1 < m_size[1]; d1++) {
	719	acc[1] = d1;
	720	element = elements [m_size.IndexFromArray(acc)];
	721	if (!Object.ReferenceEquals(element,null)) {
	722	sElement = String.Format ("{0,3:G} ", element).PadLeft(elemLength);
	723	} else {
	724	sElement = "(null)".PadLeft(elemLength);
	725	}
	726	curLineLength += sElement.Length;
	727	if (curLineLength > maxLength - " ...".Length) {
	728	s.Append(" ...");
	729	break;
	730	} else {
	731	s.Append(sElement);
	732	}
	733	}
	734	}
	735	// increase higher dimension
	736	d = 2;
	737	while (d <= m_size.NumberOfDimensions - 1) {
	738	acc[d]++;
	739	if (acc[d] < m_size[d]) break;
	740	acc[d] = 0;
	741	d++;
	742	}
	743	if (d >= m_size.NumberOfDimensions) break;
	744	}
	745	#endregion
	746
	747	} else if (this.Data.Data.GetType() == typeof( UInt64 [] )) {
	748	#region
	749	UInt64 element;
	750	UInt64 [] elements = (this.Data.Data as UInt64 []);
	751	elemLength = 18 ;
	752	double scaling = 1.0;
	753	elemLength++;
	754	while (acc[m_size.NumberOfDimensions - 1] <
	755	m_size[m_size.NumberOfDimensions - 1]) {
	756	// show only two first dimensions at the same time ...
	757	// print header
	758	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	759	if (s.Length > 0) s.Append(Environment.NewLine);
	760	s.Append("(:,:");
	761	for (d = 2; d < m_size.NumberOfDimensions; d++)
	762	s.Append(String.Format(",{0}", acc[d]));
	763	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	764	}
	765	// show this for 2 leading dimensions
	766	for (int d0 = 0; d0 < m_size[0]; d0++) {
	767	if (++curRowsCount > maxRows) {
	768	s.Append(Environment.NewLine + "( ... more rows exist)");
	769	return s;
	770	}
	771	if (s.Length > 0) s.Append(Environment.NewLine);
	772	acc[0] = d0; curLineLength = 0;
	773	for (int d1 = 0; d1 < m_size[1]; d1++) {
	774	acc[1] = d1;
	775	element = elements [m_size.IndexFromArray(acc)];
	776	if (!Object.ReferenceEquals(element,null)) {
	777	sElement = String.Format ("{0,18:G} ", element).PadLeft(elemLength);
	778	} else {
	779	sElement = "(null)".PadLeft(elemLength);
	780	}
	781	curLineLength += sElement.Length;
	782	if (curLineLength > maxLength - " ...".Length) {
	783	s.Append(" ...");
	784	break;
	785	} else {
	786	s.Append(sElement);
	787	}
	788	}
	789	}
	790	// increase higher dimension
	791	d = 2;
	792	while (d <= m_size.NumberOfDimensions - 1) {
	793	acc[d]++;
	794	if (acc[d] < m_size[d]) break;
	795	acc[d] = 0;
	796	d++;
	797	}
	798	if (d >= m_size.NumberOfDimensions) break;
	799	}
	800	#endregion
	801
	802	} else if (this.Data.Data.GetType() == typeof( UInt32 [] )) {
	803	#region
	804	UInt32 element;
	805	UInt32 [] elements = (this.Data.Data as UInt32 []);
	806	elemLength = 10 ;
	807	double scaling = 1.0;
	808	elemLength++;
	809	while (acc[m_size.NumberOfDimensions - 1] <
	810	m_size[m_size.NumberOfDimensions - 1]) {
	811	// show only two first dimensions at the same time ...
	812	// print header
	813	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	814	if (s.Length > 0) s.Append(Environment.NewLine);
	815	s.Append("(:,:");
	816	for (d = 2; d < m_size.NumberOfDimensions; d++)
	817	s.Append(String.Format(",{0}", acc[d]));
	818	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	819	}
	820	// show this for 2 leading dimensions
	821	for (int d0 = 0; d0 < m_size[0]; d0++) {
	822	if (++curRowsCount > maxRows) {
	823	s.Append(Environment.NewLine + "( ... more rows exist)");
	824	return s;
	825	}
	826	if (s.Length > 0) s.Append(Environment.NewLine);
	827	acc[0] = d0; curLineLength = 0;
	828	for (int d1 = 0; d1 < m_size[1]; d1++) {
	829	acc[1] = d1;
	830	element = elements [m_size.IndexFromArray(acc)];
	831	if (!Object.ReferenceEquals(element,null)) {
	832	sElement = String.Format ("{0,10:G} ", element).PadLeft(elemLength);
	833	} else {
	834	sElement = "(null)".PadLeft(elemLength);
	835	}
	836	curLineLength += sElement.Length;
	837	if (curLineLength > maxLength - " ...".Length) {
	838	s.Append(" ...");
	839	break;
	840	} else {
	841	s.Append(sElement);
	842	}
	843	}
	844	}
	845	// increase higher dimension
	846	d = 2;
	847	while (d <= m_size.NumberOfDimensions - 1) {
	848	acc[d]++;
	849	if (acc[d] < m_size[d]) break;
	850	acc[d] = 0;
	851	d++;
	852	}
	853	if (d >= m_size.NumberOfDimensions) break;
	854	}
	855	#endregion
	856
	857	} else if (this.Data.Data.GetType() == typeof( UInt16 [] )) {
	858	#region
	859	UInt16 element;
	860	UInt16 [] elements = (this.Data.Data as UInt16 []);
	861	elemLength = 5 ;
	862	double scaling = 1.0;
	863	elemLength++;
	864	while (acc[m_size.NumberOfDimensions - 1] <
	865	m_size[m_size.NumberOfDimensions - 1]) {
	866	// show only two first dimensions at the same time ...
	867	// print header
	868	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	869	if (s.Length > 0) s.Append(Environment.NewLine);
	870	s.Append("(:,:");
	871	for (d = 2; d < m_size.NumberOfDimensions; d++)
	872	s.Append(String.Format(",{0}", acc[d]));
	873	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	874	}
	875	// show this for 2 leading dimensions
	876	for (int d0 = 0; d0 < m_size[0]; d0++) {
	877	if (++curRowsCount > maxRows) {
	878	s.Append(Environment.NewLine + "( ... more rows exist)");
	879	return s;
	880	}
	881	if (s.Length > 0) s.Append(Environment.NewLine);
	882	acc[0] = d0; curLineLength = 0;
	883	for (int d1 = 0; d1 < m_size[1]; d1++) {
	884	acc[1] = d1;
	885	element = elements [m_size.IndexFromArray(acc)];
	886	if (!Object.ReferenceEquals(element,null)) {
	887	sElement = String.Format ("{0,5:G} ", element).PadLeft(elemLength);
	888	} else {
	889	sElement = "(null)".PadLeft(elemLength);
	890	}
	891	curLineLength += sElement.Length;
	892	if (curLineLength > maxLength - " ...".Length) {
	893	s.Append(" ...");
	894	break;
	895	} else {
	896	s.Append(sElement);
	897	}
	898	}
	899	}
	900	// increase higher dimension
	901	d = 2;
	902	while (d <= m_size.NumberOfDimensions - 1) {
	903	acc[d]++;
	904	if (acc[d] < m_size[d]) break;
	905	acc[d] = 0;
	906	d++;
	907	}
	908	if (d >= m_size.NumberOfDimensions) break;
	909	}
	910	#endregion
	911
	912	} else if (this.Data.Data.GetType() == typeof( Int64 [] )) {
	913	#region
	914	Int64 element;
	915	Int64 [] elements = (this.Data.Data as Int64 []);
	916	elemLength = 18 ;
	917	double scaling = 1.0;
	918	elemLength++;
	919	while (acc[m_size.NumberOfDimensions - 1] <
	920	m_size[m_size.NumberOfDimensions - 1]) {
	921	// show only two first dimensions at the same time ...
	922	// print header
	923	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	924	if (s.Length > 0) s.Append(Environment.NewLine);
	925	s.Append("(:,:");
	926	for (d = 2; d < m_size.NumberOfDimensions; d++)
	927	s.Append(String.Format(",{0}", acc[d]));
	928	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	929	}
	930	// show this for 2 leading dimensions
	931	for (int d0 = 0; d0 < m_size[0]; d0++) {
	932	if (++curRowsCount > maxRows) {
	933	s.Append(Environment.NewLine + "( ... more rows exist)");
	934	return s;
	935	}
	936	if (s.Length > 0) s.Append(Environment.NewLine);
	937	acc[0] = d0; curLineLength = 0;
	938	for (int d1 = 0; d1 < m_size[1]; d1++) {
	939	acc[1] = d1;
	940	element = elements [m_size.IndexFromArray(acc)];
	941	if (!Object.ReferenceEquals(element,null)) {
	942	sElement = String.Format ("{0,18:G} ", element).PadLeft(elemLength);
	943	} else {
	944	sElement = "(null)".PadLeft(elemLength);
	945	}
	946	curLineLength += sElement.Length;
	947	if (curLineLength > maxLength - " ...".Length) {
	948	s.Append(" ...");
	949	break;
	950	} else {
	951	s.Append(sElement);
	952	}
	953	}
	954	}
	955	// increase higher dimension
	956	d = 2;
	957	while (d <= m_size.NumberOfDimensions - 1) {
	958	acc[d]++;
	959	if (acc[d] < m_size[d]) break;
	960	acc[d] = 0;
	961	d++;
	962	}
	963	if (d >= m_size.NumberOfDimensions) break;
	964	}
	965	#endregion
	966
	967	} else if (this.Data.Data.GetType() == typeof( Int32 [] )) {
	968	#region
	969	Int32 element;
	970	Int32 [] elements = (this.Data.Data as Int32 []);
	971	elemLength = 10 ;
	972	double scaling = 1.0;
	973	elemLength++;
	974	while (acc[m_size.NumberOfDimensions - 1] <
	975	m_size[m_size.NumberOfDimensions - 1]) {
	976	// show only two first dimensions at the same time ...
	977	// print header
	978	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	979	if (s.Length > 0) s.Append(Environment.NewLine);
	980	s.Append("(:,:");
	981	for (d = 2; d < m_size.NumberOfDimensions; d++)
	982	s.Append(String.Format(",{0}", acc[d]));
	983	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	984	}
	985	// show this for 2 leading dimensions
	986	for (int d0 = 0; d0 < m_size[0]; d0++) {
	987	if (++curRowsCount > maxRows) {
	988	s.Append(Environment.NewLine + "( ... more rows exist)");
	989	return s;
	990	}
	991	if (s.Length > 0) s.Append(Environment.NewLine);
	992	acc[0] = d0; curLineLength = 0;
	993	for (int d1 = 0; d1 < m_size[1]; d1++) {
	994	acc[1] = d1;
	995	element = elements [m_size.IndexFromArray(acc)];
	996	if (!Object.ReferenceEquals(element,null)) {
	997	sElement = String.Format ("{0,10:G} ", element).PadLeft(elemLength);
	998	} else {
	999	sElement = "(null)".PadLeft(elemLength);
	1000	}
	1001	curLineLength += sElement.Length;
	1002	if (curLineLength > maxLength - " ...".Length) {
	1003	s.Append(" ...");
	1004	break;
	1005	} else {
	1006	s.Append(sElement);
	1007	}
	1008	}
	1009	}
	1010	// increase higher dimension
	1011	d = 2;
	1012	while (d <= m_size.NumberOfDimensions - 1) {
	1013	acc[d]++;
	1014	if (acc[d] < m_size[d]) break;
	1015	acc[d] = 0;
	1016	d++;
	1017	}
	1018	if (d >= m_size.NumberOfDimensions) break;
	1019	}
	1020	#endregion
	1021
	1022	} else if (this.Data.Data.GetType() == typeof( Int16 [] )) {
	1023	#region
	1024	Int16 element;
	1025	Int16 [] elements = (this.Data.Data as Int16 []);
	1026	elemLength = 5 ;
	1027	double scaling = 1.0;
	1028	elemLength++;
	1029	while (acc[m_size.NumberOfDimensions - 1] <
	1030	m_size[m_size.NumberOfDimensions - 1]) {
	1031	// show only two first dimensions at the same time ...
	1032	// print header
	1033	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	1034	if (s.Length > 0) s.Append(Environment.NewLine);
	1035	s.Append("(:,:");
	1036	for (d = 2; d < m_size.NumberOfDimensions; d++)
	1037	s.Append(String.Format(",{0}", acc[d]));
	1038	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	1039	}
	1040	// show this for 2 leading dimensions
	1041	for (int d0 = 0; d0 < m_size[0]; d0++) {
	1042	if (++curRowsCount > maxRows) {
	1043	s.Append(Environment.NewLine + "( ... more rows exist)");
	1044	return s;
	1045	}
	1046	if (s.Length > 0) s.Append(Environment.NewLine);
	1047	acc[0] = d0; curLineLength = 0;
	1048	for (int d1 = 0; d1 < m_size[1]; d1++) {
	1049	acc[1] = d1;
	1050	element = elements [m_size.IndexFromArray(acc)];
	1051	if (!Object.ReferenceEquals(element,null)) {
	1052	sElement = String.Format ("{0,5:G} ", element).PadLeft(elemLength);
	1053	} else {
	1054	sElement = "(null)".PadLeft(elemLength);
	1055	}
	1056	curLineLength += sElement.Length;
	1057	if (curLineLength > maxLength - " ...".Length) {
	1058	s.Append(" ...");
	1059	break;
	1060	} else {
	1061	s.Append(sElement);
	1062	}
	1063	}
	1064	}
	1065	// increase higher dimension
	1066	d = 2;
	1067	while (d <= m_size.NumberOfDimensions - 1) {
	1068	acc[d]++;
	1069	if (acc[d] < m_size[d]) break;
	1070	acc[d] = 0;
	1071	d++;
	1072	}
	1073	if (d >= m_size.NumberOfDimensions) break;
	1074	}
	1075	#endregion
	1076
	1077	} else if (this.Data.Data.GetType() == typeof( ILStorage [] )) {
	1078	#region
	1079	ILStorage element;
	1080	ILStorage [] elements = (this.Data.Data as ILStorage []);
	1081	elemLength = 0 ;
	1082	double scaling = 1.0;
	1083	for (int i = 0; i < m_size.NumberOfElements; i++) {
	1084	element = elements[i];
	1085	int l = (element == null)? 6 : element.ShortInfo().Length;
	1086	if (l > elemLength) elemLength = l;
	1087	}
	1088
	1089	elemLength++;
	1090	while (acc[m_size.NumberOfDimensions - 1] <
	1091	m_size[m_size.NumberOfDimensions - 1]) {
	1092	// show only two first dimensions at the same time ...
	1093	// print header
	1094	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	1095	if (s.Length > 0) s.Append(Environment.NewLine);
	1096	s.Append("(:,:");
	1097	for (d = 2; d < m_size.NumberOfDimensions; d++)
	1098	s.Append(String.Format(",{0}", acc[d]));
	1099	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	1100	}
	1101	// show this for 2 leading dimensions
	1102	for (int d0 = 0; d0 < m_size[0]; d0++) {
	1103	if (++curRowsCount > maxRows) {
	1104	s.Append(Environment.NewLine + "( ... more rows exist)");
	1105	return s;
	1106	}
	1107	if (s.Length > 0) s.Append(Environment.NewLine);
	1108	acc[0] = d0; curLineLength = 0;
	1109	for (int d1 = 0; d1 < m_size[1]; d1++) {
	1110	acc[1] = d1;
	1111	element = elements [m_size.IndexFromArray(acc)];
	1112	if (!Object.ReferenceEquals(element,null)) {
	1113	sElement = element.ShortInfo().PadRight(elemLength);
	1114	} else {
	1115	sElement = "(null)".PadLeft(elemLength);
	1116	}
	1117	curLineLength += sElement.Length;
	1118	if (curLineLength > maxLength - " ...".Length) {
	1119	s.Append(" ...");
	1120	break;
	1121	} else {
	1122	s.Append(sElement);
	1123	}
	1124	}
	1125	}
	1126	// increase higher dimension
	1127	d = 2;
	1128	while (d <= m_size.NumberOfDimensions - 1) {
	1129	acc[d]++;
	1130	if (acc[d] < m_size[d]) break;
	1131	acc[d] = 0;
	1132	d++;
	1133	}
	1134	if (d >= m_size.NumberOfDimensions) break;
	1135	}
	1136	#endregion
	1137
	1138	} else if (this.Data.Data.GetType() == typeof( object [] )) {
	1139	#region
	1140	object element;
	1141	object [] elements = (this.Data.Data as object []);
	1142	elemLength = 18 ;
	1143	double scaling = 1.0;
	1144	elemLength++;
	1145	while (acc[m_size.NumberOfDimensions - 1] <
	1146	m_size[m_size.NumberOfDimensions - 1]) {
	1147	// show only two first dimensions at the same time ...
	1148	// print header
	1149	if (m_size.NumberOfDimensions > 2 \|\| scaling != 1) {
	1150	if (s.Length > 0) s.Append(Environment.NewLine);
	1151	s.Append("(:,:");
	1152	for (d = 2; d < m_size.NumberOfDimensions; d++)
	1153	s.Append(String.Format(",{0}", acc[d]));
	1154	s.Append(") " + ((scaling!=1.0)? (scaling.ToString("e0") + " * "):""));
	1155	}
	1156	// show this for 2 leading dimensions
	1157	for (int d0 = 0; d0 < m_size[0]; d0++) {
	1158	if (++curRowsCount > maxRows) {
	1159	s.Append(Environment.NewLine + "( ... more rows exist)");
	1160	return s;
	1161	}
	1162	if (s.Length > 0) s.Append(Environment.NewLine);
	1163	acc[0] = d0; curLineLength = 0;
	1164	for (int d1 = 0; d1 < m_size[1]; d1++) {
	1165	acc[1] = d1;
	1166	element = elements [m_size.IndexFromArray(acc)];
	1167	if (!Object.ReferenceEquals(element,null)) {
	1168	sElement = String.Format ("{0} ", element).PadLeft(elemLength);
	1169	} else {
	1170	sElement = "(null)".PadLeft(elemLength);
	1171	}
	1172	curLineLength += sElement.Length;
	1173	if (curLineLength > maxLength - " ...".Length) {
	1174	s.Append(" ...");
	1175	break;
	1176	} else {
	1177	s.Append(sElement);
	1178	}
	1179	}
	1180	}
	1181	// increase higher dimension
	1182	d = 2;
	1183	while (d <= m_size.NumberOfDimensions - 1) {
	1184	acc[d]++;
	1185	if (acc[d] < m_size[d]) break;
	1186	acc[d] = 0;
	1187	d++;
	1188	}
	1189	if (d >= m_size.NumberOfDimensions) break;
	1190	}
	1191	#endregion
	1192
	1193	#endregion HYCALPER AUTO GENERATED CODE
	1194	} else if (this is ILDenseStorage<string> ) {
	1195	#region
	1196	string element;
	1197	string[] elements = (this.Data.Data as string[]);
	1198	elemLength = 18;
	1199	int maxElemLength = 50; // todo: may better be a setting? abreviate after as many chars
	1200	elemLength++;
	1201	while (acc[m_size.NumberOfDimensions - 1] <
	1202	m_size[m_size.NumberOfDimensions - 1]) {
	1203	// show only two first dimensions at the same time ...
	1204	// print header
	1205	if (m_size.NumberOfDimensions > 2) {
	1206	if (s.Length > 0) s.Append(Environment.NewLine);
	1207	s.Append("(:,:");
	1208	for (d = 2; d < m_size.NumberOfDimensions; d++)
	1209	s.Append(String.Format(",{0}", acc[d]));
	1210	s.Append(") ");
	1211	}
	1212	// show this for 2 leading dimensions
	1213	for (int d0 = 0; d0 < m_size[0]; d0++) {
	1214	if (++curRowsCount > maxRows) {
	1215	s.Append(Environment.NewLine + "( ... more rows exist)");
	1216	return s;
	1217	}
	1218	if (s.Length > 0) s.Append(Environment.NewLine);
	1219	acc[0] = d0; curLineLength = 0;
	1220	for (int d1 = 0; d1 < m_size[1]; d1++) {
	1221	acc[1] = d1;
	1222	element = elements[m_size.IndexFromArray(acc)];
	1223	if (!Object.ReferenceEquals(element, null)) {
	1224	if (element.Length > maxElemLength) {
	1225	sElement = element.Substring(0,maxElemLength - 3) + "...";
	1226	} else {
	1227	sElement = String.Format("{0} ", element).PadLeft(elemLength);
	1228	}
	1229	} else {
	1230	sElement = "(null)".PadLeft(elemLength);
	1231	}
	1232	curLineLength += sElement.Length;
	1233	if (curLineLength > maxLength - " ...".Length) {
	1234	s.Append(" ...");
	1235	break;
	1236	} else {
	1237	s.Append(sElement);
	1238	}
	1239	}
	1240	}
	1241	// increase higher dimension
	1242	d = 2;
	1243	while (d <= m_size.NumberOfDimensions - 1) {
	1244	acc[d]++;
	1245	if (acc[d] < m_size[d]) break;
	1246	acc[d] = 0;
	1247	d++;
	1248	}
	1249	if (d >= m_size.NumberOfDimensions) break;
	1250	}
	1251	#endregion
	1252	} else {
	1253	return new StringBuilder ("(Unknown data type.)");
	1254	}
	1255	return s;
	1256	}
	1257	private double getScalingForPrint() {
	1258	ElementType min, max;
	1259	if (GetLimits(out min, out max, false)) {
	1260	try {
	1261	double scaling = Math.Max(
	1262	Math.Abs(double.Parse(min.ToString())),
	1263	Math.Abs( double.Parse(max.ToString()))
	1264	);
	1265	if (scaling == 0 \|\| (scaling > 1e-1 && scaling < 1e1))
	1266	scaling = 1;
	1267	scaling = Math.Pow(10,Math.Floor(Math.Log10(scaling)));
	1268	if (scaling < 10000 && scaling >= 1)
	1269	scaling = 1;
	1270	return scaling;
	1271	} catch (Exception) {
	1272	return 1.0;
	1273	}
	1274	} else {
	1275	return 1.0;
	1276	}
	1277	}
	1278	private int GetTypedElementStringProperties(double scaling, out string format) {
	1279	format = "E+00000000000000;0.0;-E+00000000000000";
	1280	if (this is ILDenseStorage<double>) {
	1281	return double.MaxValue.ToString().Length;
	1282	} else if (this is ILDenseStorage<float>) {
	1283	return float.MaxValue.ToString().Length;
	1284	} else if (this is ILDenseStorage<Complex>) {
	1285	return double.MaxValue.ToString().Length * 2 + 2;
	1286	} else if (this is ILDenseStorage<complex>) {
	1287	return double.MaxValue.ToString().Length * 2 + 2;
	1288	} else if (this is ILDenseStorage<fcomplex>) {
	1289	return float.MaxValue.ToString().Length * 2 + 2;
	1290	} else if (this is ILDenseStorage<char>) {
	1291	return char.MaxValue.ToString().Length;
	1292	} else if (this is ILDenseStorage<byte>) {
	1293	return byte.MaxValue.ToString().Length;
	1294	} else if (this is ILDenseStorage<Int16>) {
	1295	return Int16.MaxValue.ToString().Length;
	1296	} else if (this is ILDenseStorage<Int32>) {
	1297	return Int32.MaxValue.ToString().Length;
	1298	} else if (this is ILDenseStorage<Int64>) {
	1299	return Int64.MaxValue.ToString().Length;
	1300	} else if (this is ILDenseStorage<UInt16>) {
	1301	return UInt16.MaxValue.ToString().Length;
	1302	} else if (this is ILDenseStorage<UInt32>) {
	1303	return UInt32.MaxValue.ToString().Length;
	1304	} else if (this is ILDenseStorage<UInt64>) {
	1305	return UInt64.MaxValue.ToString().Length;
	1306	} else
	1307	return 10;
	1308	}
	1309	private string ComplexHelper(Complex a, int digits) {
	1310	if (digits < 1) return "";
	1311	if (a.Imaginary >= 0) {
	1312	return String.Format("{0:f10}+{1:f10}", a.Real, a.Imaginary);
	1313	} else {
	1314	return String.Format("{0:f10}-{1:f10}", a.Real, -a.Imaginary);
	1315	}
	1316	}
	1317	/// <summary>
	1318	/// Check if the content of this array equals the content of obj.
	1319	/// </summary>
	1320	/// <param name="obj">storage containing the values with which to compare this array.</param>
	1321	/// <returns>True if all elements contained in obj are equal to the
	1322	/// elements of this array, false otherwise.</returns>
	1323	/// <remarks>This method compares the object references of corresponding elements.
	1324	/// The size and type of both arrays must match. Otherwise false will be returned.</remarks>
	1325	internal override bool Equals(object obj) {
	1326	if (object.Equals(obj,null)) return false;
	1327	if (obj is ElementType)
	1328	if (Size.NumberOfElements == 1
	1329	&& obj.ToString() == GetValueTyped(0).ToString())
	1330	return true;
	1331	else
	1332	return false;
	1333	ILDenseStorage<ElementType> denseStorage = obj as ILDenseStorage<ElementType>;
	1334	if (object.Equals(denseStorage,null))
	1335	return false;
	1336	return Equals(denseStorage);
	1337	}
	1338	/// <summary>
	1339	/// Test if this dense storage equals another dense storage.
	1340	/// </summary>
	1341	/// <param name="A">storage to compare this storage with</param>
	1342	/// <returns>True if all elements and dimension sizes match, false otherwise.</returns>
	1343	internal bool Equals(ILDenseStorage<ElementType> A) {
	1344	if (A == null) return false;
	1345	if (!A.Size.IsSameSize(m_size))
	1346	return false;
	1347	int len = m_size.NumberOfElements;
	1348	if (typeof(ElementType).IsValueType) {
	1349	for (int i = 0; i < len;i++) {
	1350	if (!GetValueTyped(i).Equals(A.GetValueTyped(i)))
	1351	return false;
	1352	}
	1353	} else {
	1354	// references may contain null element values!
	1355	for (int i = 0; i < len;i++) {
	1356	ElementType t1 = GetValueTyped(i);
	1357	if (t1 == null) {
	1358	if (!A.GetValueTyped(i).Equals(null))
	1359	return false;
	1360	} else {
	1361	if (!t1.Equals(A.GetValueTyped(i)))
	1362	return false;
	1363	}
	1364	}
	1365	}
	1366	return true;
	1367	}
	1368	/// <summary>
	1369	/// generate a hash code based on the current arrays values
	1370	/// </summary>
	1371	/// <returns>hash code</returns>
	1372	/// <remarks>The hashcode is generated by taking the values currently stored in the array into account.
	1373	/// Therefore, the function must iterate over all elements in the array - which makes it somehow a expensive
	1374	/// operation. Take this into account, if you consider using large arrays in collections like dictionaries
	1375	/// or hashtables, which make great use of hash codes.</remarks>
	1376	public override int GetHashCode() {
	1377	if (IsDisposed) return base.GetHashCode();
	1378	int ret = Size.GetHashCode();
	1379	ElementType[] data = GetArrayForRead();
	1380	ret = (ret * 17) + data.Length;
	1381	foreach (ElementType t in data) {
	1382	ret = unchecked( ret * 17 );
	1383	if (t != null)
	1384	ret = unchecked(ret + t.GetHashCode());
	1385	}
	1386	return (int)ret;
	1387	}
	1388	#endregion
	1389
	1390	#region subarray + range get / set
	1391	/// <summary>
	1392	/// Alter values specified by range.
	1393	/// </summary>
	1394	/// <param name="range">ILRange specifying the dimensions/indices to be altered.</param>
	1395	/// <param name="values">new values</param>
	1396	/// <remarks>
	1397	/// The values pointed to by range will be replaced with the values
	1398	/// found in 'values'. Important: the range cannot specify indices outside of my dimensions!
	1399	/// Therefore, the storage must have been expanded in advance, if needed!</remarks>
	1400	public virtual void SetRange(ILRange range, ILDenseStorage<ElementType> values) {
	1401	if (range.Size.NumberOfElements == 0) return;
	1402	int rangeDimLen = range.RangeArray.Length,higherDimSum = 0;
	1403	int leadDimLenRange = range[0].Count, leadDimLen = m_size[0];
	1404	int d, outElemCount = range.Size.NumberOfElements;
	1405	ElementType[] myArr = GetArrayForWrite();
	1406	int[] idxArr = new int[rangeDimLen]; // used to store current position inside higher dims
	1407	ILIntList[] rng = range.RangeArray;
	1408	int[] seqDistances = m_size.GetSequentialIndexDistances(range.Size.NumberOfDimensions);
	1409	int[] inFullDim = new int[rangeDimLen];
	1410	// initialize higher dimension summand and inFullDim[] flag array
	1411	for (int i = 1; i < idxArr.Length; i++) {
	1412	if (rng[i][0] < 0) {
	1413	inFullDim[i] = rng[i][0];
	1414	} else {
	1415	inFullDim[i] = 0;
	1416	higherDimSum += seqDistances[i] * rng[i][0];
	1417	}
	1418	}
	1419	//for (int lIdx = 0; lIdx < leadDimLenRange; lIdx ++) {
	1420	// retArr[curPosOut++] = myArr[higherDimSum + rleadDim[lIdx]];
	1421	//}
	1422	if (values.Size.NumberOfElements == 1) {
	1423	#region scalar case
	1424	ElementType scalar = values.GetValueTyped(0);
	1425	while (true) {
	1426	// copy along leading dimension
	1427	for (int i = 0; i < rng[0].Count; i++) {
	1428	if (rng[0][i] < 0) {
	1429	for (int c = -rng[0][i]; c-- >= 0; ) {
	1430	// we need a upward counter variable anyway, initialized with
	1431	// higherDimSum. So we simply take that and reset it after the loop:
	1432	myArr[ higherDimSum++ ] = scalar;
	1433	}
	1434	higherDimSum += (rng[0][i]-1); // negative value in rng!
	1435	} else {
	1436	myArr[ higherDimSum + rng[0][i] ] = scalar;
	1437	}
	1438
	1439	}
	1440
	1441	// increase higher dims
	1442	d = 1;
	1443	while (d < idxArr.Length) {
	1444	if (inFullDim[d] < 0) {
	1445	higherDimSum += seqDistances[d];
	1446	inFullDim[d]++;
	1447	break;
	1448	}
	1449
	1450	if (rng[d][idxArr[d]] >= 0) {
	1451	higherDimSum -= (rng[d][idxArr[d]] * seqDistances[d]);
	1452	} else {
	1453	higherDimSum += (rng[d][idxArr[d]] * seqDistances[d]);
	1454	}
	1455	idxArr[d]++;
	1456	if (idxArr[d] == rng[d].Count) {
	1457	idxArr[d] = 0;
	1458	if (rng[d][0] < 0) {
	1459	inFullDim[d] = rng[d][idxArr[d]];
	1460	} else {
	1461	higherDimSum += (rng[d][0] * seqDistances[d]);
	1462	}
	1463	d++;
	1464	} else if (rng[d][idxArr[d]] < 0) {
	1465	inFullDim[d] = rng[d][idxArr[d]];
	1466	break;
	1467	} else {
	1468	higherDimSum += seqDistances[d] * rng[d][idxArr[d]];
	1469	break;
	1470	}
	1471
	1472	}
	1473	if (d >= idxArr.Length)
	1474	break;
	1475	}
	1476	#endregion
	1477	} else {
	1478	#region non scalar case
	1479	ElementType [] valuesArr = values.GetArrayForRead();
	1480	int valuesPos = 0;
	1481	while (true) {
	1482	// copy along leading dimension
	1483	for (int i = 0; i < rng[0].Count; i++) {
	1484	if (rng[0][i] < 0) {
	1485	for (int c = -rng[0][i]; c-- >= 0; ) {
	1486	myArr[ higherDimSum++ ] = valuesArr[ valuesPos++ ];
	1487	}
	1488	higherDimSum += (rng[0][i]-1); // negative value in rng!
	1489	} else {
	1490	myArr[ higherDimSum + rng[0][i] ] = valuesArr[ valuesPos++ ];
	1491	}
	1492	}
	1493
	1494	// increase higher dims
	1495	d = 1;
	1496	while (d < idxArr.Length) {
	1497	if (inFullDim[d] < 0) {
	1498	higherDimSum += seqDistances[d];
	1499	inFullDim[d]++;
	1500	break;
	1501	}
	1502
	1503	if (rng[d][idxArr[d]] >= 0) {
	1504	higherDimSum -= (rng[d][idxArr[d]] * seqDistances[d]);
	1505	} else {
	1506	higherDimSum += (rng[d][idxArr[d]] * seqDistances[d]);
	1507	}
	1508	idxArr[d]++;
	1509	if (idxArr[d] == rng[d].Count) {
	1510	idxArr[d] = 0;
	1511	if (rng[d][idxArr[d]] < 0) {
	1512	inFullDim[d] = rng[d][idxArr[d]];
	1513	} else {
	1514	higherDimSum += (rng[d][0] * seqDistances[d]);
	1515	}
	1516	d++;
	1517	} else if (rng[d][idxArr[d]] < 0) {
	1518	inFullDim[d] = rng[d][idxArr[d]];
	1519	break;
	1520	} else {
	1521	higherDimSum += seqDistances[d] * rng[d][idxArr[d]];
	1522	break;
	1523	}
	1524
	1525	}
	1526	if (d >= idxArr.Length)
	1527	break;
	1528	}
	1529	#endregion
	1530	}
	1531	}
	1532
	1533	internal virtual void SetRangeFull(ILDenseStorage<ElementType> values) {
	1534	if (values.Size.NumberOfElements != 1 && values.Size.NumberOfElements != Size.NumberOfElements)
	1535	throw new ILArgumentException("source and destination array must have the same number of arguments");
	1536	ElementType[] myArr = GetArrayForWrite();
	1537	if (values.Size.NumberOfElements == 1) {
	1538	ElementType scal = values.GetValueTyped(0);
	1539	for (int i = 0; i < myArr.Length; i++) {
	1540	myArr[i] = scal;
	1541	}
	1542	} else {
	1543	ElementType[] valArr = values.GetArrayForRead();
	1544	System.Array.Copy(valArr,myArr,Size.NumberOfElements);
	1545	}
	1546	}
	1547
	1548
	1549
	1550	/// <summary>
	1551	/// Alter elements of this storage adressed by sequential indices
	1552	/// </summary>
	1553	/// <param name="indices">array specifying the elements to be altered, sequential indexing</param>
	1554	/// <param name="values">ILBaseArray of the same type than this array, holding the new values.
	1555	/// The number of elements of storage must match the
	1556	/// number of elements of indices. The only exception to this rule is if 'values' is a scalar array. The
	1557	/// single value of 'values' is than used to set all elements addressed by 'indices'.</param>
	1558	/// <remarks><para>For empty arrays, scalar or vectors, indices outside the current bounds for
	1559	/// this array will expand this array to the size neccessary.
	1560	/// For other arrays the sequential indices given must fit inside this arrays dimensions. </para></remarks>
	1561	public virtual void SetRange(ILBaseArray<double> indices, ILDenseStorage<ElementType> values) {
	1562	//if (object.Equals(indices,null))
	1563	// throw new ILArgumentException("indices given must not be null");
	1564	if (object.Equals(values, null))
	1565	throw new ILArgumentException("values given must not be null. Use A[ind] = null; if removal was intended.");
	1566	using (ILScope.Enter(indices)) {
	1567	#region set full shortcut
	1568	if (indices is ILFullRange \|\| object.Equals(indices, null)) {
	1569	int pos;
	1570	ElementType[] myArray = GetArrayForWrite();
	1571	if (values.Size.NumberOfElements == 1) {
	1572	pos = Size.NumberOfElements;
	1573	ElementType val = values.GetValueTyped(0);
	1574	while (pos-- > 0)
	1575	myArray[pos] = val;
	1576	} else {
	1577	if (values.Size.NumberOfElements != Size.NumberOfElements)
	1578	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1579	pos = 0;
	1580	foreach (ElementType val in values) {
	1581	myArray[pos++] = val;
	1582	}
	1583	}
	1584	} else if (indices.Size.NumberOfElements != values.Size.NumberOfElements
	1585	&& values.Size.NumberOfElements != 1)
	1586	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1587	#endregion
	1588	if (indices.IsEmpty)
	1589	return;
	1590	if (indices.Storage is ILDenseStorage< double>) {
	1591
	1592	double maxIndex, minIndex;
	1593	ILDenseStorage< double> indStorage = indices.Storage as ILDenseStorage< double>;
	1594	indStorage.GetLimits(out minIndex, out maxIndex);
	1595	if (minIndex < 0)
	1596	throw new ILArgumentException("sequential indices can not be negative");
	1597	if ((int)maxIndex >= m_size.NumberOfElements) {
	1598	// handle resize
	1599	if (m_size.NumberOfDimensions == 2) {
	1600	if (m_size.NumberOfElements <= 1) {
	1601	// scalar or empty -> expand along 1
	1602	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1603	} else if (m_size[0] > 1 && m_size[1] == 1) {
	1604	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1605	} else if (m_size[0] == 1 && m_size[1] > 1) {
	1606	ExpandArray(new int[] { 1, (int)maxIndex + 1 });
	1607	} else
	1608	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1609	} else
	1610	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1611	}
	1612	ElementType[] myArray = GetArrayForWrite();
	1613
	1614	double[] indArray = indStorage.GetArrayForRead();
	1615
	1616	int len = indices.Size.NumberOfElements;
	1617	if (values.Size.NumberOfElements == 1) {
	1618	ElementType scalarElement = values.GetValueTyped(0);
	1619	for (int i = 0; i < len; ) {
	1620	myArray[(int)indArray[i++]] = scalarElement;
	1621	}
	1622	} else {
	1623	ElementType[] valArray = values.GetArrayForRead();
	1624	for (int i = 0; i < len; ) {
	1625	myArray[(int)indArray[i]] = valArray[i++];
	1626	}
	1627	}
	1628	} else {
	1629	throw new ILArgumentException("storage type of given indices is not supported");
	1630	}
	1631	}
	1632	}
	1633
	1634	#region HYCALPER AUTO GENERATED CODE
	1635
	1636
	1637	/// <summary>
	1638	/// Alter elements of this storage adressed by sequential indices
	1639	/// </summary>
	1640	/// <param name="indices">array specifying the elements to be altered, sequential indexing</param>
	1641	/// <param name="values">ILBaseArray of the same type than this array, holding the new values.
	1642	/// The number of elements of storage must match the
	1643	/// number of elements of indices. The only exception to this rule is if 'values' is a scalar array. The
	1644	/// single value of 'values' is than used to set all elements addressed by 'indices'.</param>
	1645	/// <remarks><para>For empty arrays, scalar or vectors, indices outside the current bounds for
	1646	/// this array will expand this array to the size neccessary.
	1647	/// For other arrays the sequential indices given must fit inside this arrays dimensions. </para></remarks>
	1648	public virtual void SetRange(ILBaseArray<Int64> indices, ILDenseStorage<ElementType> values) {
	1649	//if (object.Equals(indices,null))
	1650	// throw new ILArgumentException("indices given must not be null");
	1651	if (object.Equals(values, null))
	1652	throw new ILArgumentException("values given must not be null. Use A[ind] = null; if removal was intended.");
	1653	using (ILScope.Enter(indices)) {
	1654	#region set full shortcut
	1655	if (indices is ILFullRange \|\| object.Equals(indices, null)) {
	1656	int pos;
	1657	ElementType[] myArray = GetArrayForWrite();
	1658	if (values.Size.NumberOfElements == 1) {
	1659	pos = Size.NumberOfElements;
	1660	ElementType val = values.GetValueTyped(0);
	1661	while (pos-- > 0)
	1662	myArray[pos] = val;
	1663	} else {
	1664	if (values.Size.NumberOfElements != Size.NumberOfElements)
	1665	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1666	pos = 0;
	1667	foreach (ElementType val in values) {
	1668	myArray[pos++] = val;
	1669	}
	1670	}
	1671	} else if (indices.Size.NumberOfElements != values.Size.NumberOfElements
	1672	&& values.Size.NumberOfElements != 1)
	1673	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1674	#endregion
	1675	if (indices.IsEmpty)
	1676	return;
	1677	if (indices.Storage is ILDenseStorage< Int64>) {
	1678
	1679	Int64 maxIndex, minIndex;
	1680	ILDenseStorage< Int64> indStorage = indices.Storage as ILDenseStorage< Int64>;
	1681	indStorage.GetLimits(out minIndex, out maxIndex);
	1682	if (minIndex < 0)
	1683	throw new ILArgumentException("sequential indices can not be negative");
	1684	if ((int)maxIndex >= m_size.NumberOfElements) {
	1685	// handle resize
	1686	if (m_size.NumberOfDimensions == 2) {
	1687	if (m_size.NumberOfElements <= 1) {
	1688	// scalar or empty -> expand along 1
	1689	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1690	} else if (m_size[0] > 1 && m_size[1] == 1) {
	1691	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1692	} else if (m_size[0] == 1 && m_size[1] > 1) {
	1693	ExpandArray(new int[] { 1, (int)maxIndex + 1 });
	1694	} else
	1695	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1696	} else
	1697	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1698	}
	1699	ElementType[] myArray = GetArrayForWrite();
	1700
	1701	Int64[] indArray = indStorage.GetArrayForRead();
	1702
	1703	int len = indices.Size.NumberOfElements;
	1704	if (values.Size.NumberOfElements == 1) {
	1705	ElementType scalarElement = values.GetValueTyped(0);
	1706	for (int i = 0; i < len; ) {
	1707	myArray[(int)indArray[i++]] = scalarElement;
	1708	}
	1709	} else {
	1710	ElementType[] valArray = values.GetArrayForRead();
	1711	for (int i = 0; i < len; ) {
	1712	myArray[(int)indArray[i]] = valArray[i++];
	1713	}
	1714	}
	1715	} else {
	1716	throw new ILArgumentException("storage type of given indices is not supported");
	1717	}
	1718	}
	1719	}
	1720
	1721	/// <summary>
	1722	/// Alter elements of this storage adressed by sequential indices
	1723	/// </summary>
	1724	/// <param name="indices">array specifying the elements to be altered, sequential indexing</param>
	1725	/// <param name="values">ILBaseArray of the same type than this array, holding the new values.
	1726	/// The number of elements of storage must match the
	1727	/// number of elements of indices. The only exception to this rule is if 'values' is a scalar array. The
	1728	/// single value of 'values' is than used to set all elements addressed by 'indices'.</param>
	1729	/// <remarks><para>For empty arrays, scalar or vectors, indices outside the current bounds for
	1730	/// this array will expand this array to the size neccessary.
	1731	/// For other arrays the sequential indices given must fit inside this arrays dimensions. </para></remarks>
	1732	public virtual void SetRange(ILBaseArray<Int32> indices, ILDenseStorage<ElementType> values) {
	1733	//if (object.Equals(indices,null))
	1734	// throw new ILArgumentException("indices given must not be null");
	1735	if (object.Equals(values, null))
	1736	throw new ILArgumentException("values given must not be null. Use A[ind] = null; if removal was intended.");
	1737	using (ILScope.Enter(indices)) {
	1738	#region set full shortcut
	1739	if (indices is ILFullRange \|\| object.Equals(indices, null)) {
	1740	int pos;
	1741	ElementType[] myArray = GetArrayForWrite();
	1742	if (values.Size.NumberOfElements == 1) {
	1743	pos = Size.NumberOfElements;
	1744	ElementType val = values.GetValueTyped(0);
	1745	while (pos-- > 0)
	1746	myArray[pos] = val;
	1747	} else {
	1748	if (values.Size.NumberOfElements != Size.NumberOfElements)
	1749	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1750	pos = 0;
	1751	foreach (ElementType val in values) {
	1752	myArray[pos++] = val;
	1753	}
	1754	}
	1755	} else if (indices.Size.NumberOfElements != values.Size.NumberOfElements
	1756	&& values.Size.NumberOfElements != 1)
	1757	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1758	#endregion
	1759	if (indices.IsEmpty)
	1760	return;
	1761	if (indices.Storage is ILDenseStorage< Int32>) {
	1762
	1763	Int32 maxIndex, minIndex;
	1764	ILDenseStorage< Int32> indStorage = indices.Storage as ILDenseStorage< Int32>;
	1765	indStorage.GetLimits(out minIndex, out maxIndex);
	1766	if (minIndex < 0)
	1767	throw new ILArgumentException("sequential indices can not be negative");
	1768	if ((int)maxIndex >= m_size.NumberOfElements) {
	1769	// handle resize
	1770	if (m_size.NumberOfDimensions == 2) {
	1771	if (m_size.NumberOfElements <= 1) {
	1772	// scalar or empty -> expand along 1
	1773	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1774	} else if (m_size[0] > 1 && m_size[1] == 1) {
	1775	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1776	} else if (m_size[0] == 1 && m_size[1] > 1) {
	1777	ExpandArray(new int[] { 1, (int)maxIndex + 1 });
	1778	} else
	1779	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1780	} else
	1781	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1782	}
	1783	ElementType[] myArray = GetArrayForWrite();
	1784
	1785	Int32[] indArray = indStorage.GetArrayForRead();
	1786
	1787	int len = indices.Size.NumberOfElements;
	1788	if (values.Size.NumberOfElements == 1) {
	1789	ElementType scalarElement = values.GetValueTyped(0);
	1790	for (int i = 0; i < len; ) {
	1791	myArray[(int)indArray[i++]] = scalarElement;
	1792	}
	1793	} else {
	1794	ElementType[] valArray = values.GetArrayForRead();
	1795	for (int i = 0; i < len; ) {
	1796	myArray[(int)indArray[i]] = valArray[i++];
	1797	}
	1798	}
	1799	} else {
	1800	throw new ILArgumentException("storage type of given indices is not supported");
	1801	}
	1802	}
	1803	}
	1804
	1805	/// <summary>
	1806	/// Alter elements of this storage adressed by sequential indices
	1807	/// </summary>
	1808	/// <param name="indices">array specifying the elements to be altered, sequential indexing</param>
	1809	/// <param name="values">ILBaseArray of the same type than this array, holding the new values.
	1810	/// The number of elements of storage must match the
	1811	/// number of elements of indices. The only exception to this rule is if 'values' is a scalar array. The
	1812	/// single value of 'values' is than used to set all elements addressed by 'indices'.</param>
	1813	/// <remarks><para>For empty arrays, scalar or vectors, indices outside the current bounds for
	1814	/// this array will expand this array to the size neccessary.
	1815	/// For other arrays the sequential indices given must fit inside this arrays dimensions. </para></remarks>
	1816	public virtual void SetRange(ILBaseArray<Int16> indices, ILDenseStorage<ElementType> values) {
	1817	//if (object.Equals(indices,null))
	1818	// throw new ILArgumentException("indices given must not be null");
	1819	if (object.Equals(values, null))
	1820	throw new ILArgumentException("values given must not be null. Use A[ind] = null; if removal was intended.");
	1821	using (ILScope.Enter(indices)) {
	1822	#region set full shortcut
	1823	if (indices is ILFullRange \|\| object.Equals(indices, null)) {
	1824	int pos;
	1825	ElementType[] myArray = GetArrayForWrite();
	1826	if (values.Size.NumberOfElements == 1) {
	1827	pos = Size.NumberOfElements;
	1828	ElementType val = values.GetValueTyped(0);
	1829	while (pos-- > 0)
	1830	myArray[pos] = val;
	1831	} else {
	1832	if (values.Size.NumberOfElements != Size.NumberOfElements)
	1833	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1834	pos = 0;
	1835	foreach (ElementType val in values) {
	1836	myArray[pos++] = val;
	1837	}
	1838	}
	1839	} else if (indices.Size.NumberOfElements != values.Size.NumberOfElements
	1840	&& values.Size.NumberOfElements != 1)
	1841	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1842	#endregion
	1843	if (indices.IsEmpty)
	1844	return;
	1845	if (indices.Storage is ILDenseStorage< Int16>) {
	1846
	1847	Int16 maxIndex, minIndex;
	1848	ILDenseStorage< Int16> indStorage = indices.Storage as ILDenseStorage< Int16>;
	1849	indStorage.GetLimits(out minIndex, out maxIndex);
	1850	if (minIndex < 0)
	1851	throw new ILArgumentException("sequential indices can not be negative");
	1852	if ((int)maxIndex >= m_size.NumberOfElements) {
	1853	// handle resize
	1854	if (m_size.NumberOfDimensions == 2) {
	1855	if (m_size.NumberOfElements <= 1) {
	1856	// scalar or empty -> expand along 1
	1857	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1858	} else if (m_size[0] > 1 && m_size[1] == 1) {
	1859	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1860	} else if (m_size[0] == 1 && m_size[1] > 1) {
	1861	ExpandArray(new int[] { 1, (int)maxIndex + 1 });
	1862	} else
	1863	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1864	} else
	1865	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1866	}
	1867	ElementType[] myArray = GetArrayForWrite();
	1868
	1869	Int16[] indArray = indStorage.GetArrayForRead();
	1870
	1871	int len = indices.Size.NumberOfElements;
	1872	if (values.Size.NumberOfElements == 1) {
	1873	ElementType scalarElement = values.GetValueTyped(0);
	1874	for (int i = 0; i < len; ) {
	1875	myArray[(int)indArray[i++]] = scalarElement;
	1876	}
	1877	} else {
	1878	ElementType[] valArray = values.GetArrayForRead();
	1879	for (int i = 0; i < len; ) {
	1880	myArray[(int)indArray[i]] = valArray[i++];
	1881	}
	1882	}
	1883	} else {
	1884	throw new ILArgumentException("storage type of given indices is not supported");
	1885	}
	1886	}
	1887	}
	1888
	1889	/// <summary>
	1890	/// Alter elements of this storage adressed by sequential indices
	1891	/// </summary>
	1892	/// <param name="indices">array specifying the elements to be altered, sequential indexing</param>
	1893	/// <param name="values">ILBaseArray of the same type than this array, holding the new values.
	1894	/// The number of elements of storage must match the
	1895	/// number of elements of indices. The only exception to this rule is if 'values' is a scalar array. The
	1896	/// single value of 'values' is than used to set all elements addressed by 'indices'.</param>
	1897	/// <remarks><para>For empty arrays, scalar or vectors, indices outside the current bounds for
	1898	/// this array will expand this array to the size neccessary.
	1899	/// For other arrays the sequential indices given must fit inside this arrays dimensions. </para></remarks>
	1900	public virtual void SetRange(ILBaseArray<float> indices, ILDenseStorage<ElementType> values) {
	1901	//if (object.Equals(indices,null))
	1902	// throw new ILArgumentException("indices given must not be null");
	1903	if (object.Equals(values, null))
	1904	throw new ILArgumentException("values given must not be null. Use A[ind] = null; if removal was intended.");
	1905	using (ILScope.Enter(indices)) {
	1906	#region set full shortcut
	1907	if (indices is ILFullRange \|\| object.Equals(indices, null)) {
	1908	int pos;
	1909	ElementType[] myArray = GetArrayForWrite();
	1910	if (values.Size.NumberOfElements == 1) {
	1911	pos = Size.NumberOfElements;
	1912	ElementType val = values.GetValueTyped(0);
	1913	while (pos-- > 0)
	1914	myArray[pos] = val;
	1915	} else {
	1916	if (values.Size.NumberOfElements != Size.NumberOfElements)
	1917	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1918	pos = 0;
	1919	foreach (ElementType val in values) {
	1920	myArray[pos++] = val;
	1921	}
	1922	}
	1923	} else if (indices.Size.NumberOfElements != values.Size.NumberOfElements
	1924	&& values.Size.NumberOfElements != 1)
	1925	throw new ILArgumentException("number of elements in source must match number of elements in destination array");
	1926	#endregion
	1927	if (indices.IsEmpty)
	1928	return;
	1929	if (indices.Storage is ILDenseStorage< float>) {
	1930
	1931	float maxIndex, minIndex;
	1932	ILDenseStorage< float> indStorage = indices.Storage as ILDenseStorage< float>;
	1933	indStorage.GetLimits(out minIndex, out maxIndex);
	1934	if (minIndex < 0)
	1935	throw new ILArgumentException("sequential indices can not be negative");
	1936	if ((int)maxIndex >= m_size.NumberOfElements) {
	1937	// handle resize
	1938	if (m_size.NumberOfDimensions == 2) {
	1939	if (m_size.NumberOfElements <= 1) {
	1940	// scalar or empty -> expand along 1
	1941	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1942	} else if (m_size[0] > 1 && m_size[1] == 1) {
	1943	ExpandArray(new int[] { (int)maxIndex + 1, 1 });
	1944	} else if (m_size[0] == 1 && m_size[1] > 1) {
	1945	ExpandArray(new int[] { 1, (int)maxIndex + 1 });
	1946	} else
	1947	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1948	} else
	1949	throw new ILArgumentException("resizing array via sequential index access is supported for empty, scalar or vector only");
	1950	}
	1951	ElementType[] myArray = GetArrayForWrite();
	1952
	1953	float[] indArray = indStorage.GetArrayForRead();
	1954
	1955	int len = indices.Size.NumberOfElements;
	1956	if (values.Size.NumberOfElements == 1) {
	1957	ElementType scalarElement = values.GetValueTyped(0);
	1958	for (int i = 0; i < len; ) {
	1959	myArray[(int)indArray[i++]] = scalarElement;
	1960	}
	1961	} else {
	1962	ElementType[] valArray = values.GetArrayForRead();
	1963	for (int i = 0; i < len; ) {
	1964	myArray[(int)indArray[i]] = valArray[i++];
	1965	}
	1966	}
	1967	} else {
	1968	throw new ILArgumentException("storage type of given indices is not supported");
	1969	}
	1970	}
	1971	}
	1972
	1973	#endregion HYCALPER AUTO GENERATED CODE
	1974
	1975	/// <summary>
	1976	/// Create referencing or solid array from this array, with shifted dimensions.
	1977	/// </summary>
	1978	/// <param name="shift">Number of dimensions to shift the array.</param>
	1979	/// <returns>Shifted ILDenseStorage of the same type.</returns>
	1980	/// <remarks><para>Shift is done 'to the left'.</para></remarks>
	1981	public virtual ILDenseStorage<ElementType> ShiftDimensions (int shift) {
	1982	return CreateShiftedStorage(shift);
	1983	}
	1984
	1985	#endregion
	1986
	1987	#region Reshape, Concat, Repmat - overriding ILBaseArray<ElementType>
	1988
	1989	/// <summary>
	1990	/// reshape <b>this</b> storage
	1991	/// </summary>
	1992	/// <param name="newDimensions">new dimensions of the storage.</param>
	1993	/// <remarks><para>This storage will be changed! The operation is cheap, since the
	1994	/// number of elements (and their values) do not change. The same countable array
	1995	/// is used in conjunction with a new dimension specifier. </para>
	1996	/// </remarks>
	1997	/// <exception cref="ILNumerics.Exceptions.ILArgumentException">If the number of elements in 'newDimension'
	1998	/// do not match the number of elements in this storage.</exception>
	1999	internal void Reshape(ILSize newDimensions) {
	2000	if (newDimensions.NumberOfElements != m_size.NumberOfElements)
	2001	throw new ILArgumentSizeException ("the number of elements must not change");
	2002	m_size = newDimensions;
	2003	}
	2004	/// <summary>
	2005	/// reshape <b>this</b> storage
	2006	/// </summary>
	2007	/// <param name="dims">new dimension length of the storage.</param>
	2008	/// <remarks><para>This storage will be changed! The operation is cheap, since the
	2009	/// number of elements (and their values) do not change. The same underlying storage
	2010	/// is used in conjunction with the new dimension specifier.</para>
	2011	/// </remarks>
	2012	/// <exception cref="ILNumerics.Exceptions.ILArgumentException">If the number of elements in 'newDimension'
	2013	/// do not match the number of elements in this storage.</exception>
	2014	public void Reshape(params int[] dims) {
	2015	ILSize newDimension = new ILSize(dims);
	2016	Reshape(newDimension);
	2017	}
	2018	/// <summary>
	2019	/// concatenate this storage
	2020	/// </summary>
	2021	/// <param name="A">n dimensional storage</param>
	2022	/// <param name="dim">Index of dimension along which to concatenate the arrays.
	2023	/// If dim is larger than the number of dimensions of one of the arrays
	2024	/// its value will be used in modulus.</param>
	2025	/// <returns>Array having the size of both input arrays laid beside one
	2026	/// another along the <paramref name="dim"/>'s-dimension</returns>
	2027	/// <remarks>The array returned will be a copy of both arrays involved. None
	2028	/// of the input arrays will be altered.</remarks>
	2029	public virtual ILDenseStorage<ElementType> Concat(ILDenseStorage<ElementType> A, int dim) {
	2030	ILSize inDim = A.m_size;
	2031	for (int i = 0; i < Math.Max(inDim.NumberOfDimensions, m_size.NumberOfDimensions); i++) {
	2032	if (i != dim)
	2033	if (m_size[i] != inDim[i])
	2034	throw new ILArgumentSizeException("the length of dimensions of both arrays (except the dimension "
	2035	+ "to be concatenated) must match");
	2036	}
	2037	// concatenate
	2038	if (inDim.NumberOfElements == 1 && m_size.NumberOfElements == 1) {
	2039	// both scalars
	2040	int[] dims = new int[2] { 1, 1 };
	2041	dims[dim] = 2;
	2042	ElementType[] retArr = ILMemoryPool.Pool.New<ElementType>(2);
	2043	retArr[0] = m_data.Data[0];
	2044	retArr[1] = A.m_data.Data[0];
	2045	return CreateSelf(retArr, new ILSize(dims));
	2046	}
	2047	int lenOutArr = m_size.NumberOfElements + inDim.NumberOfElements;
	2048	int[] retDims = m_size.ToIntArray(dim+1);
	2049	retDims[dim] += inDim[dim];
	2050	ILSize retDimension = new ILSize(retDims);
	2051	ElementType[] retData = ILMemoryPool.Pool.New<ElementType>(retDimension.NumberOfElements);
	2052	ElementType[] myData = GetArrayForRead();
	2053	ElementType[] inData = A.GetArrayForRead();
	2054
	2055	int len1 = m_size.SequentialIndexDistance(dim + 1);
	2056	int len2 = inDim.SequentialIndexDistance(dim + 1);
	2057	int posOutArr = 0, inPos = 0, myPos = 0;
	2058	while (posOutArr < lenOutArr) {
	2059	for (int i = 0; i < len1; i++)
	2060	retData[posOutArr++] = myData[myPos++];
	2061	for (int i = 0; i < len2; i++)
	2062	retData[posOutArr++] = inData[inPos++];
	2063	}
	2064	return CreateSelf(retData,retDimension);
	2065	}
	2066
	2067	/// <summary>
	2068	/// Replicate this storage to create a larger array.
	2069	/// </summary>
	2070	/// <param name="sizes">Sizes description. This may be a
	2071	/// list or an array of integer values. If the number of elements in <paramref name="sizes"/> is
	2072	/// less the number of dimensions in this array, the trailing dimensions will
	2073	/// be set to 1 (singleton dimensions). On the other hand, if the number specified
	2074	/// is larger then the number of dimensions of this array, the result
	2075	/// will have its number of dimensions extended accordingly. </param>
	2076	/// <returns>array which is made out of multiple copies of this array along
	2077	/// specified dimensions, according to <paramref name="sizes"/>.</returns>
	2078	internal virtual ILDenseStorage<ElementType> Repmat(params int[] sizes) {
	2079	if (m_size.NumberOfElements == 0)
	2080	return CreateSelf(new ILSize(sizes));
	2081	ILRightSideRange rsRange = new ILRightSideRange(m_size, sizes);
	2082	return CreateSubarrayStorage(rsRange);
	2083
	2084
	2085	// experimental: via subindexing full dimensions
	2086	//ILBaseArray[] dimArrays = new ILBaseArray[dims.Length];
	2087	//for (int i = 0; i < dimArrays.Length; i++) {
	2088	// dimArrays[i] = ILMath.cell(ILMath.full)[ILMath.zeros(1,dims[i])];
	2089	//}
	2090	//return Subarray(dimArrays);
	2091
	2092	//build return dimensions
	2093	//int[] newDim = new int[Math.Max(dims.Length, m_dimensions.NumberOfDimensions)];
	2094	//for (int d = 0; d < newDim.Length; d++) {
	2095	// if (d < dims.Length) {
	2096	// newDim[d] = m_dimensions[d] * dims[d];
	2097	// } else {
	2098	// newDim[d] = m_dimensions[d];
	2099	// }
	2100	//}
	2101	//ILSize outDim = new ILSize(true, newDim);
	2102	//if (m_dimensions.NumberOfElements == 0 \|\| outDim.NumberOfElements == 0)
	2103	// return new ILDenseStorage<ElementType>(new ILCountableArray<ElementType>(0), outDim);
	2104	//ILDenseStorage<ElementType> ret = new ILDenseStorage<ElementType>(
	2105	// new ILCountableArray<ElementType>(outDim.NumberOfElements), outDim);
	2106	//ElementType[] retArray = ret.GetArrayForWrite();
	2107	//ElementType[] myArray = GetArrayForRead();
	2108	//int[] outStrides = outDim.GetSequentialIndexDistances(m_dimensions.NumberOfDimensions);
	2109	//int[] myStrides = m_dimensions.GetSequentialIndexDistances(m_dimensions.NumberOfDimensions);
	2110	//retArray[0] = myArray[0];
	2111	//if (outDim.NumberOfElements < ILNumerics.Settings.s_minParallelElement1Count) {
	2112	// for (int outPos = 1; outPos < outDim.NumberOfElements; ) {
	2113	// int inPos = 0;
	2114	// for (int d = m_dimensions.NumberOfDimensions; d-- > 0; ) {
	2115	// inPos += ((outPos / outStrides[d]) % m_dimensions[d])
	2116	// * myStrides[d];
	2117	// }
	2118	// retArray[outPos++] = myArray[inPos];
	2119	// }
	2120	//} else {
	2121	// System.Threading.Tasks.Parallel.For(1,outDim.NumberOfElements, i => {
	2122	// int inPos = 0;
	2123	// for (int d = m_dimensions.NumberOfDimensions; d-- > 0; ) {
	2124	// inPos += ((i / outStrides[d]) % m_dimensions[d])
	2125	// * myStrides[d];
	2126	// }
	2127	// retArray[i] = myArray[inPos];
	2128	// });
	2129	//}
	2130	//return ret;
	2131	}
	2132
	2133	/// <summary>
	2134	/// Remove individual parts of a dimension from <b>this</b> storage
	2135	/// </summary>
	2136	/// <param name="dimension">index of the dimension, where <c>indices</c> are to be removed</param>
	2137	/// <param name="indices">indices to be removed from <paramref name="dimension"/>, -1 for "wipe" (make this an empty storage)</param>
	2138	/// <remarks>The function directly operates on <b>this</b> storage! After the function returns,
	2139	/// this storage may have its dimensions changed!</remarks>
	2140	internal virtual void Remove(int dimension, ILIntList indices) {
	2141	using (ILScope.Enter()) {
	2142	if (dimension >= Size.NumberOfDimensions)
	2143	throw new ILArgumentException("index out of range");
	2144	if (dimension == -1) {
	2145	Data = new ILCountableArray<ElementType>(0);
	2146	m_size = ILSize.Empty00;
	2147	return;
	2148	}
	2149	// TODO: may should be replaced with a faster (&fancier? ) version... ??
	2150	ILBaseArray[] dims = new ILBaseArray[Size.NumberOfDimensions];
	2151	ILIntList keepInd = ILIntList.Create();
	2152	ILIntList remvInd = indices;
	2153	int max = Size[dimension];
	2154	foreach (int i in indices)
	2155	if (i >= max \|\| i < 0) throw new ILArgumentException("removal index out of range");
	2156	for (int i = 0; i < max; i++) {
	2157	if (!remvInd.Contains(i)) {
	2158	keepInd.Add(i);
	2159	}
	2160	}
	2161	// we give the indices to _keep_ to the subarray function
	2162	int keepIndCount = keepInd.Count;
	2163	ILArray<int> remIndices = ILMath.array<int>(keepInd.GetArray(), new ILSize(1, keepIndCount));
	2164	if (remIndices.Size.NumberOfElements == Size[dimension]) {
	2165	// nothing to do
	2166	return;
	2167	}
	2168	for (int i = 0; i < dims.Length; i++) {
	2169	dims[i] = ILMath.full;
	2170	}
	2171	dims[dimension] = remIndices;
	2172	ILDenseStorage<ElementType> ret = Subarray(dims);
	2173	Dispose(); // this will for reference element types (e.g. ILCell) also dispose the removed elements
	2174
	2175	Data = ret.Data;
	2176	m_size = ret.Size;
	2177
	2178	}
	2179	}
	2180
	2181	#endregion
	2182
	2183	#region serialize
	2184	/// <summary>
	2185	/// Prepare for serialization.
	2186	/// </summary>
	2187	/// <param name="context">Streaming Context - provided by the formatter.</param>
	2188	/// <remarks>nothing to do here</remarks>
	2189	[OnSerializing]
	2190	private void OnSerialize(StreamingContext context) {
	2191	}
	2192
	2193	/// <summary>
	2194	/// Post operations aftre deserializing is finished.
	2195	/// </summary>
	2196	/// <param name="context">Streaming context provided by the formatter.</param>
	2197	/// <remarks>nothing to do here</remarks>
	2198	[OnDeserialized]
	2199	void OnDeserialized(StreamingContext context) {
	2200	}
	2201
	2202	#endregion
	2203
	2204	#region single element access
	2205
	2206	/// <summary>
	2207	/// Get single value from this storage.
	2208	/// </summary>
	2209	/// <param name="idx">Integer array holding the dimension specifier</param>
	2210	/// <returns>Element at the position pointed to by idx.</returns>
	2211	internal override object GetValue(params int[] idx) {
	2212	return GetValueTyped(idx);
	2213	}
	2214	/// <summary>
	2215	/// Get single value from this storage.
	2216	/// </summary>
	2217	/// <param name="idx">Integer array holding the dimension specifier</param>
	2218	/// <returns>Element at the position pointed to by idx.</returns>
	2219	internal override ElementType GetValueTyped(params int[] idx) {
	2220	if (idx.Length == 1)
	2221	return m_data.Data[idx[0]];
	2222	int destIdx = idx[0], d, highDims;
	2223	if (destIdx >= m_size[0] \|\| destIdx < 0)
	2224	throw new ILArgumentException("GetValue: index out of bound for dimensions: 0");
	2225	int [] seqDist = m_size.GetSequentialIndexDistances(0);
	2226	if (idx.Length <= m_size.NumberOfDimensions) {
	2227	for (d = 1; d < idx.Length - 1; d++) {
	2228	if (idx[d] >= m_size[d] \|\| idx[d] < 0)
	2229	throw new ILArgumentException("GetValue: index out of bound for dimensions: " + d.ToString());
	2230	destIdx += idx[d] * seqDist[d];
	2231	}
	2232	for (highDims = idx[d]; d<m_size.NumberOfDimensions && highDims > 0; d++) {
	2233	destIdx += (highDims % m_size[d]) * seqDist[d];
	2234	highDims /= m_size[d];
	2235	}
	2236	if (highDims > 0) throw new ILArgumentException ("GetValue: index out of bound!");
	2237	return m_data.Data[destIdx];
	2238	} else {
	2239	highDims = m_size.NumberOfDimensions;
	2240	for (d = 1; d < highDims; d++) {
	2241	if (idx[d] >= m_size[d] \|\| idx[d] < 0)
	2242	throw new ILArgumentException("GetValue: index out of bound for dimensions: " + d.ToString());
	2243	destIdx += idx[d] * seqDist[d];
	2244	}
	2245	for (; d<idx.Length; d++) {
	2246	if (idx[d] != 0)
	2247	throw new ILArgumentException("GetValue: index out of bound for dimension: " + d.ToString() + ". Trailing indices must be 0!");
	2248	}
	2249	return m_data.Data[destIdx];
	2250	}
	2251	}
	2252	internal override ILStorage GetValueAsStorage(params int[] innerIndices) {
	2253	return new ILDenseStorage<ElementType>(new ElementType[1] { GetValueTyped(innerIndices) }, ILSize.Scalar1_1);
	2254	}
	2255	internal override ILBaseArray GetAsBaseArray() {
	2256	return new ILRetArray<ElementType>((ILDenseStorage<ElementType>)Clone());
	2257	}
	2258
	2259	/// <summary>
	2260	/// Get single value from this storage by a single sequential access.
	2261	/// </summary>
	2262	/// <param name="idx">Integer array holding the dimension specifier
	2263	/// pointing to the value.</param>
	2264	/// <param name="dims">Out value: return position mapped to dimensions.</param>
	2265	/// <returns>Object in the position pointed to by idx.</returns>
	2266	/// <remarks>dims is the final position into the array for the sequential index specification <c>idx</c>.</remarks>
	2267	internal override object GetValueSeq(int idx, ref int[] dims) {
	2268	int IdxCpy = idx;
	2269	for (int d = 0; d<m_size.NumberOfDimensions; d++) {
	2270	dims[d] = (IdxCpy % m_size[d]);
	2271	IdxCpy /= m_size[d]; // must go to end, to fully clear dims
	2272	}
	2273	return m_data.Data[idx];
	2274	}
	2275	/// <summary>
	2276	/// Set single value to element at the specified index.
	2277	/// </summary>
	2278	/// <param name="value">New value.</param>
	2279	/// <param name="idx">Index of the element to be altered.</param>
	2280	internal override void SetValue(object value, params int[] idx) {
	2281	try {
	2282	SetValueTyped((ElementType)value, idx);
	2283	} catch (InvalidCastException) {
	2284	SetValueTyped((ElementType)Convert.ChangeType(value, typeof(ElementType)), idx);
	2285	}
	2286	}
	2287	/// <summary>
	2288	/// Set value of element at the specified position.
	2289	/// </summary>
	2290	/// <param name="value">new value</param>
	2291	/// <param name="idx">position of the element to be altered</param>
	2292	/// <remarks><para>This function does support automatic expansion of the array
	2293	/// if indices lay outside the dimension limits of the array. However, because
	2294	/// of ambiguity reasons this is not reliable supported for vector sized arrays.</para></remarks>
	2295	internal override void SetValueTyped(ElementType value, params int[] idx) {
	2296	try {
	2297	if (idx.Length < 2) {
	2298	if (idx.Length == 1) {
	2299	if (idx[0] >= m_size.NumberOfElements)
	2300	throw new IndexOutOfRangeException();
	2301	GetArrayForWrite()[idx[0]] = value;
	2302	}
	2303	return;
	2304	}
	2305	int i = m_size.IndexFromArray(idx);
	2306	if (i >= m_size.NumberOfElements)
	2307	throw new IndexOutOfRangeException();
	2308	GetArrayForWrite()[i] = (ElementType)value;
	2309	} catch (Exception exc) {
	2310	if (exc is ILArgumentException
	2311	\|\| exc is IndexOutOfRangeException ) {
	2312	// expanding ?
	2313	int [] dimensions = m_size.ToIntArray(Math.Max(idx.Length,m_size.NumberOfDimensions));
	2314	bool mustExpand = false;
	2315	int i = m_size.IndexFromArray(ref mustExpand, ref dimensions, idx);
	2316	if (mustExpand) {
	2317	ExpandArray(dimensions);
	2318	m_data.Data[i] = value;
	2319	} else {
	2320	throw;
	2321	}
	2322	}
	2323	}
	2324	}
	2325
	2326	/// <summary>
	2327	/// [depricated] Convert index array into sequential index for storage access.
	2328	/// </summary>
	2329	/// <param name="idx">int array with dimension specification.</param>
	2330	/// <returns>Index of requested value inside the solid storage. This
	2331	/// value can directly be used to query the corresponding value via GetArrayForRead()[return_value].
	2332	/// </returns>
	2333	/// <remarks><b>This function is deprecated! Use <see cref="ILNumerics.ILSize.IndexFromArray(int[])"/> instead!</b><br/>
	2334	/// If the length of idx is smaler than the number of dimensions
	2335	/// of this storage, the trailing dimensions will be replaced with "0". I.e
	2336	/// the first index of each non specified dimension will be used.
	2337	/// If length of idx is larger than the dimensions of this storage, the behavior
	2338	/// is undefined. Therefore this function should be enclosed in try, catch blocks
	2339	/// to handle this case!</remarks>
	2340	internal int getBaseIndex(params int[] idx) {
	2341	// arghs! -> ugly! piuh!!
	2342	if (idx == null) throw new ILArgumentException("indices specified must not be null");
	2343	if (idx.Length < m_size.NumberOfDimensions) {
	2344	bool dummy;
	2345	int [] tmp = ILMemoryPool.Pool.New<int>(m_size.NumberOfDimensions,true, out dummy);
	2346	for (int i = 0; i < idx.Length; i++) {
	2347	tmp[i] = idx[i];
	2348	}
	2349	return m_size.IndexFromArray(tmp);
	2350	}
	2351	return m_size.IndexFromArray(idx);
	2352	}
	2353	/// <summary>
	2354	/// [depricated] Convert index array into sequential index for storage access. Ommit any bound checking.
	2355	/// </summary>
	2356	/// <param name="idx">int array with dimensions specification.</param>
	2357	/// <param name="MustExpand">Output parameter. On return determine, if the index
	2358	/// specification points outside of the dimensions of this ILDenseStorage and the array
	2359	/// must be expanded before accessing elements on that position.</param>
	2360	/// <param name="dimensions">if the array was found to be expanded, this are the
	2361	/// needed dimension sizes for the new array. The sizes are computed from the range
	2362	/// specification given.</param>
	2363	/// <returns>Index of requested value inside the solid storage. This
	2364	/// value may directly be used to query the value via m_data[return_value].
	2365	/// The value returned is valid for solid storages as well as for reference
	2366	/// storages.
	2367	/// </returns>
	2368	/// <remarks>
	2369	/// <para>idx must be not null and must contain at least one element.</para>
	2370	/// <para>If the length of idx is smaler than the number of dimensions
	2371	/// of this storage, the trailing dimensions will be replaced with "0". I.e
	2372	/// the first index of each non specified dimensions will be used.
	2373	/// If length of idx is larger than the dimensions of this storage, the index of
	2374	/// the expanded array will be returned.</para></remarks>
	2375	internal int getBaseIndex(ref bool MustExpand, ref int[] dimensions, params int[] idx) {
	2376	int destIdx = 0;
	2377	if (idx.Length == 1) {
	2378	destIdx = idx[0];
	2379	if (destIdx < 0)
	2380	throw new ILArgumentException("check index for dimension 0!");
	2381	if (destIdx >= m_size.NumberOfElements) {
	2382	MustExpand = true;
	2383	dimensions[0] = destIdx + 1;
	2384	}
	2385	return destIdx;
	2386	}
	2387	return m_size.IndexFromArray(ref MustExpand, ref dimensions, idx);
	2388	}
	2389	/// <summary>
	2390	/// Copy values of all elements into System.Array.
	2391	/// </summary>
	2392	/// <param name="result">System.Array, holding all element values of this ILDenseStorage.</param>
	2393	/// <remarks>The System.Array may be predefined. If its length is sufficient, it will be used and
	2394	/// its leading elements will be overwritten when function returns. If 'result' is null or has too few elements,
	2395	/// it will be recreated from the ILNumerics memory pool.</remarks>
	2396	public void ExportValues(ref ElementType[] result) {
	2397	if (result == null \|\| result.Length < m_size.NumberOfElements)
	2398	result = ILMemoryPool.Pool.New<ElementType>(m_size.NumberOfElements);
	2399	int pos = 0;
	2400	foreach (ElementType v in this) {
	2401	result[pos++] = v;
	2402	}
	2403	}
	2404	/// <summary>
	2405	/// Get direct reference to inner System.Array storage for <b>write access</b>
	2406	/// </summary>
	2407	/// <returns>reference to inner System.Array</returns>
	2408	/// <remarks>Altering this array can be done directly. If necessary, the array is detached before
	2409	/// returned. Watch the column order format of storages in ILNumerics! Keep in minds, the length
	2410	/// of the array may exceeds the number of elements.
	2411	/// <para>Accessing the inner system array directly should be left to ILNumerics experts only!
	2412	/// Unless you really know, what you are doing, you should rather use the higher order access
	2413	/// methods provided by ILArray<T>! (You have been warned!)</para></remarks>
	2414	internal ElementType[] GetArrayForWrite() {
	2415	if (m_data.ReferenceCount > 1) {
	2416	Detach();
	2417	}
	2418	return m_data.Data;
	2419	}
	2420	/// <summary>
	2421	/// Get direct reference to inner System.Array storage for <b>read access</b>
	2422	/// </summary>
	2423	/// <returns>reference to inner System.Array for reading</returns>
	2424	/// <remarks>This method is provided for experts only! Altering elements of this
	2425	/// array may cause the data to be invalidated or corrupted! Use this array only for reading! Note
	2426	/// the ILNumerics array storage format (column major). Keep in mind, the length
	2427	/// of the array may exceeds the number of elements!
	2428	/// <para>Accessing the inner system array directly should be left to ILNumerics experts only!
	2429	/// Unless you really know, what you are doing, you should rather use the higher order access
	2430	/// methods provided by ILArray<T>! (You have been warned!)</para></remarks>
	2431	internal ElementType[] GetArrayForRead() {
	2432	//if (PendingTasks > 0)
	2433	// System.Threading.SpinWait.SpinUntil(() => { return PendingTasks == 0; });
	2434	return m_data.Data;
	2435	}
	2436
	2437	#endregion
	2438
	2439	/// <summary>
	2440	/// Create lazy,shallow copy of this array
	2441	/// </summary>
	2442	/// <returns>ILDenseStorage as copy of this storage.</returns>
	2443	/// <remarks>The ILDenseStorage object returned will be of the same size and type than this object.
	2444	/// <para>The copy is done lazy. This means, the new storage will at first share the memory
	2445	/// with that storage. This will take almost no memory / processor time. As soon as attempts
	2446	/// are made to <b>alter</b> the new storage, it will be detached from this storage and use own memeory.</para></remarks>
	2447	internal override ILStorage Clone() {
	2448	return CreateSelf(m_data,m_size);
	2449	}
	2450	internal ILCountableArray<ElementType> GetDataArray() {
	2451	return m_data;
	2452	}
	2453	internal virtual void IndexSubrange(ILDenseStorage<ElementType> value, ILBaseArray[] range) {
	2454	using (ILScope.Enter(range)) {
	2455	if (Object.ReferenceEquals(value, null) \|\| value.Size.NumberOfElements == 0) {
	2456	#region remove
	2457	if (range == null) return;
	2458
	2459	ILLeftSideRange rng = new ILLeftSideRange(Size, range);
	2460	if (rng.Expanding) {
	2461	throw new ILArgumentException("invalid range for removal specified");
	2462	}
	2463	if (rng.Size.NumberOfElements == 0) {
	2464	return;
	2465	}
	2466	int nonFullDims = 0;
	2467	int dimIdx = -1;
	2468	// check validity
	2469	for (int i = 0; i < rng.RangeArray.Length; i++) {
	2470	if (rng[i].Count != 1 \|\| rng[i][0] >= 0) {
	2471	if (++nonFullDims > 1)
	2472	throw new ILArgumentException("for removal only one dimension can be 'non-full'");
	2473	dimIdx = i;
	2474	foreach (int ind in rng[i]) {
	2475	if (ind < 0) {
	2476	throw new ILArgumentException("invalid removal indices: all but at most one dimensions must be specified as 'full'. check dimension #" + i.ToString());
	2477	}
	2478	}
	2479	}
	2480	}
	2481	// remove
	2482	ILSize newDim = new ILSize(Size.ToIntArrayEx(rng.RangeArray.Length));
	2483	ILSize oldDimensions = Size;
	2484	try {
	2485	Reshape(newDim); // <- cheap!
	2486	if (dimIdx >= 0) {
	2487	Remove(dimIdx, rng[dimIdx]); // <- expensive!
	2488	} else {
	2489	// all dims full specified
	2490	Remove(dimIdx, null); // <- expensive!
	2491	}
	2492	} catch (Exception) {
	2493	Reshape(oldDimensions);
	2494	throw;
	2495	}
	2496	#endregion
	2497	} else {
	2498	#region setrange
	2499	if (range == null \|\| range.Length == 0) {
	2500	return;
	2501	} else if (range.Length == 1) {
	2502	if (range[0] is ILDenseArray<double>) {
	2503	SetRange(range[0] as ILDenseArray<double>, value);
	2504	return;
	2505	} else if (range[0] is ILDenseArray<string>) {
	2506	// special case? A[":;0:3;0:end;..."] -> multiple dimensions given as single string
	2507	string indStr = (string)(range[0] as ILDenseArray<string>).GetValue(0);
	2508	string[] dimParts = indStr.Split(';');
	2509	if (dimParts.Length == 0) {
	2510	// empty range given
	2511	return;
	2512	} else if (dimParts.Length > 1) {
	2513	range = new ILBaseArray[dimParts.Length];
	2514	for (int i = 0; i < dimParts.Length; i++) {
	2515	range[i] = dimParts[i];
	2516	}
	2517	// re-enter function to push the new arrays into scope
	2518	IndexSubrange(value,range);
	2519	return;
	2520	} else {
	2521	ILBaseArray indices = ILRange.ParseDimension(indStr, Size.NumberOfElements);
	2522	if (indices is ILBaseArray<Misc.ILFullRange>) {
	2523	SetRangeFull(value);
	2524	} else {
	2525	SetRange(indices as ILDenseArray<int>, value);
	2526	}
	2527	return;
	2528	}
	2529	} else if (range[0] is ILDenseArray<float>) {
	2530	SetRange(range[0] as ILDenseArray<float>, value);
	2531	return;
	2532	} else if (range[0] is ILDenseArray<Int32>) {
	2533	SetRange(range[0] as ILDenseArray<Int32>, value);
	2534	return;
	2535	} else if (range[0] is ILDenseArray<Int64>) {
	2536	SetRange(range[0] as ILDenseArray<Int64>, value);
	2537	return;
	2538	} else if (range[0] is ILLogical) {
	2539	SetRange(ILNumerics.ILMath.find(range[0] as ILLogical), value);
	2540	return;
	2541	} else if (range[0] is ILRetLogical) {
	2542	SetRange(ILNumerics.ILMath.find(range[0] as ILRetLogical), value);
	2543	return;
	2544	}
	2545	}
	2546	ILLeftSideRange rng = new ILLeftSideRange(Size, range);
	2547	if (rng.Expanding) {
	2548	ExpandArray(rng);
	2549	}
	2550	SetRange(rng, value);
	2551	#endregion
	2552	}
	2553	}
	2554	}
	2555
	2556	#region IEnumerable<ILBaseArray<ElementType>> Member
	2557
	2558	/// <summary>
	2559	/// enumerator returning elements as ElementType
	2560	/// </summary>
	2561	public override IEnumerator<ElementType> GetEnumerator ( ) {
	2562	int len = m_size.NumberOfElements;
	2563	ElementType[] myData = GetArrayForRead();
	2564	for (int i = 0; i < len; i++)
	2565	yield return myData[i];
	2566	}
	2567	#endregion
	2568
	2569	#region private helper
	2570	/// <summary>
	2571	/// helper function to gather some parameters for partial dimension removal
	2572	/// </summary>
	2573	/// <param name="rng">object with index specifications. May be of
	2574	/// type ILBaseArray[] with numeric arrays or a string array according
	2575	/// to the format of <see cref="ILNumerics.Storage.ILRange"/>.
	2576	/// </param>
	2577	/// <param name="dimensionIdx">Out parameter: index of dimension the indices to be removed lie in.</param>
	2578	/// <param name="indices">Indices to be removed.</param>
	2579	/// <param name="dimensions">Dimension structure, can be used to reshape the storage <b>before</b> the removal</param>
	2580	/// <remarks>If range comprises a range dimension specification which is smaller than
	2581	/// the actual number of dimension of this storage, the storage must be reshaped in advance of the removal.
	2582	/// This reshaping proccess will <b>not</b> be done inside this function! However
	2583	/// the <c>dimension</c> value returned reflects the size of the storage before removing and therefore
	2584	/// can be utilized for reshaping the storage.</remarks>
	2585	/// <exception cref="ILNumerics.Exceptions.ILArgumentException">If:<list type="bullet">
	2586	/// <item>The length of range exceeds the dimensions of this storage.</item>
	2587	/// <item>More than one or less than one dimension of <c>range</c> was not null.</item>
	2588	/// <item>The type of range was invalid, or</item>
	2589	/// <item>Range is of type <see cref="ILNumerics.ILBaseArray"/>, but the element type is not numeric</item>
	2590	/// </list></exception>
	2591	internal void ExtractRemovalParameter(ILBaseArray[] rng, out int dimensionIdx, ref ILIntList indices, out ILSize dimensions) {
	2592	dimensionIdx = 0;
	2593	dimensions = null;
	2594	if (rng.Length > m_size.NumberOfDimensions)
	2595	throw new ILArgumentException("Error removing: dimension specification exceeds matrix dimensions.");
	2596	int specCount = 0;
	2597	int tmp = 0;
	2598	if (rng.Length == 1 && rng[0] is ILBaseArray<string>) {
	2599	string allRangeString = (string)(rng[0] as ILBaseArray<string>).GetValue(0);
	2600	string[] ranges = allRangeString.Split(';');
	2601	if (ranges.Length > 1) {
	2602	rng = new ILBaseArray[ranges.Length];
	2603	for (int i = 0; i < ranges.Length; i++) {
	2604	rng[i] = ranges[i];
	2605	}
	2606	}
	2607	}
	2608	int[] outDim = Size.GetReshapedSize(rng.Length);
	2609	for (int i = 0; i < rng.Length; i++) {
	2610	if (object.Equals(rng[i], null)) {
	2611	// nothing to remove
	2612	if (indices != null) {
	2613	indices.Clear();
	2614	}
	2615	return;
	2616	} else if (!rng[i].IsEmpty) {
	2617	if (rng[i] is ILDenseArray<string>) {
	2618	string stringVal = (rng[i] as ILDenseArray<string>).GetValue(0);
	2619	ILBaseArray indFromString = ILRange.ParseDimension(stringVal,outDim[i]);
	2620	if (!(indFromString is ILBaseArray<ILFullRange>)) {
	2621	if (specCount++ > 0) {
	2622	throw new ILArgumentException("only one dimension can be non-fully specified for removal");
	2623	}
	2624	dimensionIdx = i;
	2625	indices = new ILIntList(indFromString as ILDenseArray<int>);
	2626	}
	2627	continue;
	2628	}
	2629	dimensionIdx = i;
	2630	if (specCount++ > 0) {
	2631	throw new ILArgumentException("only one dimension can be non-fully specified for removal");
	2632	}
	2633	if (rng[i] is ILBaseArray<Expression>) {
	2634	// A[end + ...] given
	2635	Expression expr = (rng[i] as ILBaseArray<Expression>).GetValue(0);
	2636	int exprVal = ILExpression.Evaluate(expr, Size[i] - 1);
	2637	indices = ILIntList.Create();
	2638	for (int p = 0; p < tmp; p++) {
	2639	indices.Add(exprVal);
	2640	}
	2641	} else if (rng[i] is ILLogical) {
	2642	ILArray<double> ind = ILNumerics.ILMath.find((ILLogical) rng[i]);
	2643	tmp = ind.Size.NumberOfElements;
	2644	indices = ILIntList.Create();
	2645	for (int p = 0; p < tmp; p++) {
	2646	indices.Add((int)ind.GetValue(p));
	2647	}
	2648	} else if (rng[i] is ILRetLogical) {
	2649	ILArray<double> ind = ILNumerics.ILMath.find((ILRetLogical) rng[i]);
	2650	tmp = ind.Size.NumberOfElements;
	2651	indices = ILIntList.Create();
	2652	for (int p = 0; p < tmp; p++) {
	2653	indices.Add((int)ind.GetValue(p));
	2654	}
	2655
	2656	/* !HC:TYPELIST:
	2657	<hycalper>
	2658	<type>
	2659	<source locate="after">
	2660	inArr1
	2661	</source>
	2662	<destination>float</destination>
	2663	<destination>Int16</destination>
	2664	<destination>Int32</destination>
	2665	<destination>Int64</destination>
	2666	<destination>byte</destination>
	2667	</type>
	2668	</hycalper>
	2669	*/
	2670
	2671	} else if (rng[i] is ILDenseArray<double> ) {
	2672	ILDenseArray<double> ind = rng[i] as ILDenseArray<double> ;
	2673	tmp = ind.Size.NumberOfElements;
	2674	indices = ILIntList.Create();
	2675	for (int p = 0; p < tmp; p++) {
	2676	indices.Add((int)ind.GetValue(p));
	2677	}
	2678
	2679	#region HYCALPER AUTO GENERATED CODE
	2680
	2681	/* !HC:TYPELIST:
	2682
	2683	*/
	2684
	2685	} else if (rng[i] is ILDenseArray<byte> ) {
	2686	ILDenseArray<byte> ind = rng[i] as ILDenseArray<byte> ;
	2687	tmp = ind.Size.NumberOfElements;
	2688	indices = ILIntList.Create();
	2689	for (int p = 0; p < tmp; p++) {
	2690	indices.Add((int)ind.GetValue(p));
	2691	}
	2692	/* !HC:TYPELIST:
	2693
	2694	*/
	2695
	2696	} else if (rng[i] is ILDenseArray<Int64> ) {
	2697	ILDenseArray<Int64> ind = rng[i] as ILDenseArray<Int64> ;
	2698	tmp = ind.Size.NumberOfElements;
	2699	indices = ILIntList.Create();
	2700	for (int p = 0; p < tmp; p++) {
	2701	indices.Add((int)ind.GetValue(p));
	2702	}
	2703	/* !HC:TYPELIST:
	2704
	2705	*/
	2706
	2707	} else if (rng[i] is ILDenseArray<Int32> ) {
	2708	ILDenseArray<Int32> ind = rng[i] as ILDenseArray<Int32> ;
	2709	tmp = ind.Size.NumberOfElements;
	2710	indices = ILIntList.Create();
	2711	for (int p = 0; p < tmp; p++) {
	2712	indices.Add((int)ind.GetValue(p));
	2713	}
	2714	/* !HC:TYPELIST:
	2715
	2716	*/
	2717
	2718	} else if (rng[i] is ILDenseArray<Int16> ) {
	2719	ILDenseArray<Int16> ind = rng[i] as ILDenseArray<Int16> ;
	2720	tmp = ind.Size.NumberOfElements;
	2721	indices = ILIntList.Create();
	2722	for (int p = 0; p < tmp; p++) {
	2723	indices.Add((int)ind.GetValue(p));
	2724	}
	2725	/* !HC:TYPELIST:
	2726
	2727	*/
	2728
	2729	} else if (rng[i] is ILDenseArray<float> ) {
	2730	ILDenseArray<float> ind = rng[i] as ILDenseArray<float> ;
	2731	tmp = ind.Size.NumberOfElements;
	2732	indices = ILIntList.Create();
	2733	for (int p = 0; p < tmp; p++) {
	2734	indices.Add((int)ind.GetValue(p));
	2735	}
	2736
	2737	#endregion HYCALPER AUTO GENERATED CODE
	2738	} else
	2739	throw new ILArgumentTypeException("error removing: invalid dimensions specifier, dimension #" + i.ToString());
	2740	}
	2741	}
	2742	if (indices == null) {
	2743	dimensionIdx = 0;
	2744	dimensions = m_size;
	2745	//indices = new int[0] { };
	2746	return;
	2747	}
	2748	// if only one dimension specified -> make row vector
	2749	//if (rng.Length < 2) {
	2750	// outDim[1] = outDim[0];
	2751	// outDim[0] = 1;
	2752	// dimensionIdx = 1;
	2753	//}
	2754	dimensions = new ILSize(outDim);
	2755	}
	2756
	2757	/// <summary>
	2758	/// Expanded <b>this</b> storage for index addressing outside of my dimensions
	2759	/// </summary>
	2760	/// <param name="range">range specification with size for destination array</param>
	2761	internal void ExpandArray (ILLeftSideRange range) {
	2762	int[] outDims;
	2763	int i= 0;
	2764	ILSize outDimensions;
	2765	if (range.Size.NumberOfDimensions > m_size.NumberOfDimensions) {
	2766	outDims = new int[range.Size.NumberOfDimensions];
	2767	for (; i < m_size.NumberOfDimensions; i ++) {
	2768	outDims[i] = (range.ExpandDimensions[i] > m_size[i]) ?
	2769	range.ExpandDimensions[i] : m_size[i];
	2770	}
	2771	for(; i < range.Size.NumberOfDimensions; i++)
	2772	outDims[i] = range.ExpandDimensions[i];
	2773	} else {
	2774	outDims = new int[m_size.NumberOfDimensions];
	2775	for (; i < range.Size.NumberOfDimensions; i ++) {
	2776	outDims[i] = (range.ExpandDimensions[i] > m_size[i]) ?
	2777	range.ExpandDimensions[i] : m_size[i];
	2778	}
	2779	for(; i < m_size.NumberOfDimensions; i++)
	2780	outDims[i] = m_size[i];
	2781	}
	2782	outDimensions = new ILSize(outDims);
	2783	ElementType [] outData = ILMemoryPool.Pool.New<ElementType>(outDimensions.NumberOfElements);
	2784	// transfer old data to new array
	2785	int [] tmpIdx = new int[outDims.Length];
	2786	for (i = 0; i < m_size.NumberOfElements; i++) {
	2787	ElementType tmp = (ElementType)GetValueSeq(i,ref tmpIdx);
	2788	outData[outDimensions.IndexFromArray(tmpIdx)] = tmp;
	2789	}
	2790	// exchange my data
	2791	Data = new ILCountableArray<ElementType>(outData, outDimensions.NumberOfElements);
	2792	m_size = outDimensions;
	2793	}
	2794	/// <summary>
	2795	/// Expand <b>this</b> storage for index addressing outside of my dimensions
	2796	/// </summary>
	2797	/// <param name="indices">sizes of dimensions for the new storage</param>
	2798	protected void ExpandArray(int[] indices) {
	2799	if (indices.Length == 2 && (indices[0] * indices[1] == 0)) {
	2800	if (indices[0] > 0)
	2801	indices[1] = 1;
	2802	else if (indices[1] > 0)
	2803	indices[0] = 1;
	2804	}
	2805	ILSize outDimensions = new ILSize(indices);
	2806	bool cleared;
	2807	ElementType [] outData = ILMemoryPool.Pool.New<ElementType>(outDimensions.NumberOfElements,true,out cleared);
	2808	// transfer old data to new array
	2809	int [] tmpIdx = new int[indices.Length];
	2810	for (int i = 0; i < m_size.NumberOfElements; i++) {
	2811	ElementType tmpData = (ElementType)GetValueSeq(i,ref tmpIdx);
	2812	outData[outDimensions.IndexFromArray(tmpIdx)] = tmpData;
	2813	}
	2814	// replace with my data
	2815	Data = new ILCountableArray<ElementType>(outData,outDimensions.NumberOfElements);
	2816	m_size = outDimensions;
	2817	}
	2818	/// <summary>
	2819	/// Copy upper triangular part of this array into new solid array.
	2820	/// </summary>
	2821	/// <param name="n">Length of first dimension of destination array.</param>
	2822	/// <returns>Solid array of size [n x {ThisColumnCount})].</returns>
	2823	internal ILDenseStorage<ElementType> copyUpperTriangle(int n) {
	2824	ILDenseStorage<ElementType> ret = new ILDenseStorage<ElementType>(new ILSize(n,n));
	2825	ElementType[] arr = ret.GetArrayForWrite();
	2826	ElementType[] myData = GetArrayForRead();
	2827	if (m_size[0] == n) {
	2828	for (int rcount = 0 , pos = 0; rcount < n; rcount++) {
	2829	for (int i = 0; i <= rcount; i++) {
	2830	arr[pos] = myData[pos++];
	2831	}
	2832	pos += (n - rcount - 1);
	2833	}
	2834	} else {
	2835	for (int rcount = 0 , posIn = 0, posOut = 0, lenA = m_size[0]; rcount < n; rcount++) {
	2836	for (int i = 0; i <= rcount; i++) {
	2837	arr[posOut++] = myData[posIn++];
	2838	}
	2839	posOut += (n - rcount - 1);
	2840	posIn += (lenA - rcount - 1);
	2841	}
	2842	}
	2843	return ret;
	2844	}
	2845	/// <summary>
	2846	/// Copy lower triangular part of this array into new solid array.
	2847	/// </summary>
	2848	/// <returns>Solid array of same size than this array.</returns>
	2849	/// <remarks>If this is not a 2D array, only the first dimension is referenced.</remarks>
	2850	internal ILDenseStorage<ElementType> copyLowerTriangle() {
	2851	int n = m_size[0],pos = 0;
	2852	ILDenseStorage<ElementType> ret = new ILDenseStorage<ElementType>(new ILSize(n,n));
	2853	ElementType[] arr = ret.GetArrayForRead();
	2854	ElementType[] myData = GetArrayForRead();
	2855	for (int c = 0; c < m_size[1]; c++) {
	2856	pos += c;
	2857	for (int r = c; r < n; r++,pos++) {
	2858	arr[pos] = myData[pos];
	2859	pos++;
	2860	}
	2861	}
	2862	return ret;
	2863	}
	2864
	2865	#endregion
	2866
	2867	}
	2868	}

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

Download in other formats:

Update cookies preferences