/// <summary> /// size of array A /// </summary> /// <param name="A">input array</param> /// <returns>double ILArray with the length of each dimension of A.</returns> /// <remarks>If A is null, an empty array will be returned. Otherwise the array returned will always be a row vector of length s. s >= 2</remarks> public static ILArray<double> size(ILBaseArray A) { if (object.Equals (A,null)) return ILArray<double>.empty(0,0); int numDim = A.Dimensions.NumberOfDimensions; double [] retArr = new double[numDim]; for (int i = 0; i < numDim; i++) { retArr[i] = A.Dimensions[i]; } return new ILArray<double>(retArr,1,numDim); }
public static bool TestEqualSloppy (ILBaseArray A, ILBaseArray B) { if (A is ILArray<double>) { if (B is ILArray<double>) { return isequalwithequalnans(A as ILArray<double>,B as ILArray<double>); } else if (B is ILArray<complex>) { ILArray<complex> Bc = B as ILArray<complex>; if (Bc == null) return false; if (any(imag(Bc)).NumberTrues > 0) { //if (any(isinf(imag(Bc)) != isinf(real(Bc))).NumberTrues > 0) return false; if (any(imag(Bc)[find(!isinf(Bc))]).NumberTrues > 0) return false; } return isequalwithequalnans(A as ILArray<double>, real(Bc)); } return false; } else if (A is ILArray<float>) { if (B is ILArray<float>) { return isequalwithequalnans(A as ILArray<float>,B as ILArray<float>); } else if (B is ILArray<fcomplex>) { ILArray<fcomplex> Bf = B as ILArray<fcomplex>; if (Bf == null) return false; if (any(imag(Bf)).NumberTrues > 0) { //if (any(isinf(imag(Bf)) != isinf(real(Bf))).NumberTrues > 0) return false; if (any(imag(Bf)[find(!isinf(Bf))]).NumberTrues > 0) return false; } return isequalwithequalnans(A as ILArray<fcomplex>, real(Bf)); } return false; } else if (A is ILArray<complex>) { if (B is ILArray<complex>) { return isequalwithequalnans(A as ILArray<complex>, B as ILArray<complex>); } else if (B is ILArray<double>) { ILArray<complex> Ac = A as ILArray<complex>; if (A == null) return false; if (any(imag(Ac)).NumberTrues > 0) { //if (any(isinf(imag(Ac)) != isinf(real(Ac))).NumberTrues > 0) return false; if (any(imag(Ac)[find(!isinf(Ac))]).NumberTrues > 0) return false; } return isequalwithequalnans(real(Ac),B as ILArray<double>); } else return false; } else if (A is ILArray<fcomplex>) { if (B is ILArray<fcomplex>) { return isequalwithequalnans(A as ILArray<fcomplex>, B as ILArray<fcomplex>); } else if (B is ILArray<float>) { ILArray<fcomplex> Af = A as ILArray<fcomplex>; if (Af == null) return false; if (any(imag(Af)).NumberTrues > 0) { //if (any(isinf(imag(Af)) != isinf(real(Af))).NumberTrues > 0) return false; if (any(imag(Af)[find(!isinf(Af))]).NumberTrues > 0) return false; } return isequalwithequalnans(real(Af),B as ILArray<float>); } else return false; } else { return A.Equals(B); } }
/// <summary> /// get storage length of inner array elements /// </summary> /// <param name="arr">base array in question</param> /// <returns>storage length in bytes</returns> private static int getElementLength(ILBaseArray arr) { Type arrType = arr.GetType(); string innerType; if (arr is ILLogicalArray) return 1; if (!arrType.IsGenericType) throw new ILInvalidOperationException("The array type to be saved is not applicable!"); innerType = arrType.GetGenericArguments()[0].Name; switch (innerType) { case "Double": return miSIZE_DOUBLE; case "Single": return miSIZE_SINGLE; case "Int16": return miSIZE_INT16; case "Int32": return miSIZE_INT32; case "Int64": return 16; case "UInt16": return miSIZE_UINT16; case "UInt32": return miSIZE_UINT32; case "UInt64": return 16; case "complex": return miSIZE_DOUBLE; case "fcomplex": return miSIZE_SINGLE; case "Byte": return miSIZE_INT8; case "Char": return miSIZE_UINT16; default: throw new ILInvalidOperationException("Arrays of inner element type: '" + innerType + "' can not be written as Matfile!"); } }
/// <summary> /// get mat file array class type corresponding to this arra element type /// </summary> /// <param name="arr">arra with generic system type or complex/fcomplex</param> /// <returns>mat file array class type code (int value)</returns> private static int getElementClass(ILBaseArray arr) { Type arrType = arr.GetType(); if (arr is ILLogicalArray) return (int)MatFileArrayClass.mxINT8_CLASS; if (!arrType.IsGenericType) throw new ILInvalidOperationException("The array type to be saved is not applicable!"); string innerType = arrType.GetGenericArguments()[0].Name; switch (innerType) { case "Double": return (int)MatFileArrayClass.mxDOUBLE_CLASS; case "Single": return (int)MatFileArrayClass.mxSINGLE_CLASS; case "Int16": return (int)MatFileArrayClass.mxINT16_CLASS; case "Int32": return (int)MatFileArrayClass.mxINT32_CLASS; case "Int64": throw new ILInvalidOperationException("Int64 array class can not be written as Matfile!"); case "UInt16": return (int)MatFileArrayClass.mxUINT16_CLASS; case "UInt32": return (int)MatFileArrayClass.mxUINT32_CLASS; case "UInt64": throw new ILInvalidOperationException("UInt64 array class can not be written as Matfile!"); case "complex": return (int)MatFileArrayClass.mxDOUBLE_CLASS; case "fcomplex": return (int)MatFileArrayClass.mxSINGLE_CLASS; case "Byte": return (int)MatFileArrayClass.mxINT8_CLASS; case "Char": return (int)MatFileArrayClass.mxCHAR_CLASS; default: throw new ILInvalidOperationException("Arrays of inner element type: '" + innerType + "' can not be written as Matfile!"); } }
private int[] createDimensionSubelement (ILBaseArray arr) { int[] ret; int LengthInt; // determine length of dimensions array byte (padding to full 8 byte border) if (arr.Dimensions.NumberOfDimensions % 2 == 0) { LengthInt = (arr.Dimensions.NumberOfDimensions + 2); } else { // must pad to 8 byte border LengthInt = (arr.Dimensions.NumberOfDimensions + 3); } ret = new int[LengthInt]; ret[0] = (int)MatFileType.miINT32; ret[1] = arr.Dimensions.NumberOfDimensions * 4; for (int i = 0; i < arr.Dimensions.NumberOfDimensions; i++) { ret[i+2] = arr.Dimensions[i]; } return ret; }
protected ErrorHandlerProcessMethod ProcessParameterErrorInfo(int id, ILBaseArray parameter0, int nrInputParams, int nrOutputParams, int failedResultNo, ILMatFile inputMatfile, ILMatFile outputMatfile, string functionDefinition) { // determine how to proceed with the error if (m_ignoreAllErrors || m_manualIgnoreIds.Contains(id)) { if (!m_manualIgnoreIds.Contains(id)) m_manualIgnoreIds.Add(id); return ErrorHandlerProcessMethod.IgnoreAll; } Console.ResetColor(); Console.WriteLine("Press 'i' for extended error information! (will continue in " + m_errorWaitForUserInputSec.ToString() + " sec otherwise)"); DateTime end = DateTime.Now + TimeSpan.FromSeconds(m_errorWaitForUserInputSec); while (!Console.KeyAvailable && DateTime.Now < end) { System.Threading.Thread.Sleep(100); } if (Console.KeyAvailable && Console.ReadKey().Key == ConsoleKey.I) { // function definition Console.WriteLine("Function: {0}",functionDefinition); // write error infos: input parameters for (int i = 0; i < nrInputParams; i++) { Console.WriteLine("Input parameter #{0}:\r\n#############################\r\n{1}", i, inputMatfile["input_" + id.ToString() + "_" + i.ToString()].ToString()); } // write error infos: output parameters for (int i = 0; i < nrOutputParams; i++) { Console.WriteLine("Expected output parameter #{0}:\r\n#############################\r\n{1}", i, outputMatfile["output_" + id.ToString() + "_" + i.ToString()].ToString()); } Console.WriteLine("Result #{0} returned unexpected value: \r\n ############################\r\n{1}", failedResultNo, parameter0.ToString()); // ask how to proceed ConsoleKey pressedKey = ConsoleKey.NoName; while (pressedKey != ConsoleKey.A && pressedKey != ConsoleKey.I && pressedKey != ConsoleKey.P && pressedKey != ConsoleKey.L) { Console.WriteLine("_A_bort / _I_gnore/ _P_ermanently ignore / Ignore al_L_ "); while (!Console.KeyAvailable) { System.Threading.Thread.Sleep(100); } pressedKey = Console.ReadKey(false).Key; } if (pressedKey == ConsoleKey.A) { Console.WriteLine("Aborting..."); return ErrorHandlerProcessMethod.Abort; } else if (pressedKey == ConsoleKey.L) { Console.WriteLine("All errors will be ignored in future runs of this test ..."); m_manualIgnoreIds.Add(id); m_ignoreAllErrors = true; return ErrorHandlerProcessMethod.IgnoreAll; } else if (pressedKey == ConsoleKey.I) { Console.WriteLine("The error will be ignored in this test ..."); return ErrorHandlerProcessMethod.IgnoreAll; } else if (pressedKey == ConsoleKey.P) { Console.WriteLine("The error will be permanently ignored in this test ..."); m_manualIgnoreIds.Add(id); return ErrorHandlerProcessMethod.IgnoreAll; } } return ErrorHandlerProcessMethod.Ignore; }
protected void CheckManualOverwrite(int waitAutoContinueMs, ILMatFile inputs, ILMatFile outputsExt, int id, int nrInputParams, int nrOutputParams, int idFailedOutput, ILBaseArray failedOutputILN) { // give extensive error info Console.Out.WriteLine("Failure! ####################################"); Console.Out.WriteLine("Should extensive error information be displayed? (y/n)"); if (Console.In.Read() == 1) return; // waits for n msec for user input // skip // overwrite }
/// <summary> /// length of one specific dimension of A /// </summary> /// <param name="A">input array</param> /// <param name="dim">number of dimension to query the length for</param> /// <returns>length of dimension 'dim'</returns> public static int size(ILBaseArray A, int dim) { if (object.Equals(A,null) || dim < 0) throw new ILArgumentException("size: A must not be null"); return A.Dimensions[dim]; }
/// <summary> /// Deserialize an ILLogicalArray from stream /// </summary> /// <param name="inStream">strem to read from</param> /// <returns>ILLogicalArray deserialized from stream</returns> public new static ILLogicalArray Deserialize(System.IO.Stream inStream) { return((ILLogicalArray)ILBaseArray <Byte> .Deserialize(inStream)); }
/// <summary> /// create new lit surface, provide heights (Z values) /// </summary> /// <param name="panel">the panel hosting the scene</param> /// <param name="Z">data matrix, at least 2 rows, 2 columns</param> public ILLitSurface(ILPanel panel, ILBaseArray Z) : this(panel, Z, new ILColormap(Colormaps.ILNumerics)) { }
/// <summary> /// create new lit surface, provide data for X,Y and Z coordinates /// </summary> /// <param name="panel">the panel hosting the scene</param> /// <param name="X">X coordinates matrix, same size as Z or null</param> /// <param name="Y">Y coordinates matrix, same size as Z or null</param> /// <param name="Z">Z data matrix, at least 2 rows, 2 columns</param> /// <param name="colormap">colormap used for auto coloring the surface</param> public ILLitSurface(ILPanel panel, ILBaseArray X, ILBaseArray Y, ILBaseArray Z, ILColormap colormap) : base(panel) { if (Z == null || Z.Dimensions[0] < 2 || Z.Dimensions[1] < 2) throw new ArgumentException("invalid parameter size: Z"); if (X == null || !X.Dimensions.IsSameSize(Z.Dimensions)) throw new ArgumentException("invalid parameter size: X"); if (Y == null || !Y.Dimensions.IsSameSize(Z.Dimensions)) throw new ArgumentException("invalid parameter size: Y"); m_quads = new ILLitQuads(panel, Z.Dimensions.NumberOfElements); m_quads.Label.Text = ""; m_quads.Shading = ShadingStyles.Interpolate; Add(m_quads); m_colorMap = colormap; ZValues = Z; XValues = X; YValues = Y; Invalidate(); }
/// <summary> /// helper function to prepare parameters for partial removal /// </summary> /// <param name="range">object with index specification.May be of /// type ILBaseArray[] with numeric arrays or a string array according /// to the format of <see cref="ILNumerics.Storage.ILRange"/>. /// </param> /// <param name="dimensionIdx">out parameter: number of dimension the indices to be removed lay in</param> /// <param name="indices">indices to be removed</param> /// <param name="dimensions">dimension structure, may be used if the array must be /// reshaped <b>before</b> the removal.</param> /// <remarks>if range consists out of a range specification wich is smaller than /// the actual dimension length of this array, the array must also be reshaped in order to remove /// the data accordingly. This reshape proccess will <b>not</b> be done inside of this function! However /// ther <c>dimension</c> value returned reflect the size of the array before removing and therefore /// may comfortable be used for reshaping the array.</remarks> /// <exception cref="ILNumerics.Exceptions.ILArgumentException">if <list type="bullet"> /// <item>the length of range exceeds the dimensions of this array</item> /// <item>more or less than exactly one dimension of <c>range</c> was not null</item> /// <item>the type of range was invalid, or</item> /// <item>range is of type array of <see cref="ILNumerics.ILBaseArray"/>, but the elements are non numeric ILArray's</item> /// </list></exception> private void ExtractRemovalParameter(object[] range, out int dimensionIdx, out int[] indices, out ILDimension dimensions) { dimensionIdx = 0; indices = null; dimensions = null; int inDimCount = 0; // if (range.Length > m_dimensions.NumberOfDimensions) { throw new ILArgumentException("Error removing: dimension specification exceeds matrix dimensions."); } int specCount = 0; int tmp = 0; inDimCount = range.Length; // for (int i = 0; i < range.Length; i++) { if (range[i] is ILBaseArray) { #region ILBaseArray input ILBaseArray rng = (ILBaseArray)range[i]; if (rng != null && !rng.IsEmpty) { dimensionIdx = i; if (specCount++ > 0) { throw new ILArgumentException("Error removing: only one dimension must be non-empty!"); } if (false) { } else if (rng is ILLogicalArray) { ILArray <double> ind = ILNumerics.BuiltInFunctions.ILMath.find((ILLogicalArray)rng); tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } #region HYCALPER LOOPSTART /* !HC:TYPELIST: * <hycalper> * <type> * <source locate="after"> * inCls1 * </source> * <destination><![CDATA[ILArray<float>]]></destination> * <destination><![CDATA[ILArray<Int16>]]></destination> * <destination><![CDATA[ILArray<Int32>]]></destination> * <destination><![CDATA[ILArray<Int64>]]></destination> * <destination><![CDATA[ILArray<UInt16>]]></destination> * <destination><![CDATA[ILArray<UInt32>]]></destination> * <destination><![CDATA[ILArray<UInt64>]]></destination> * <destination><![CDATA[ILArray<char>]]></destination> * <destination><![CDATA[ILArray<byte>]]></destination> * <destination><![CDATA[ILArray<complex>]]></destination> * <destination><![CDATA[ILArray<fcomplex>]]></destination> * </type> * </hycalper> */ } else if (rng is /*!HC:inCls1*/ ILArray <double> ) { /*!HC:inCls1*/ ILArray <double> ind = (/*!HC:inCls1*/ ILArray <double>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } #endregion HYCALPER LOOPEND #region HYCALPER AUTO GENERATED CODE // DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !! /* !HC:TYPELIST: * */ } else if (rng is ILArray <fcomplex> ) { ILArray <fcomplex> ind = (ILArray <fcomplex>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <complex> ) { ILArray <complex> ind = (ILArray <complex>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <byte> ) { ILArray <byte> ind = (ILArray <byte>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <char> ) { ILArray <char> ind = (ILArray <char>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <UInt64> ) { ILArray <UInt64> ind = (ILArray <UInt64>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <UInt32> ) { ILArray <UInt32> ind = (ILArray <UInt32>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <UInt16> ) { ILArray <UInt16> ind = (ILArray <UInt16>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <Int64> ) { ILArray <Int64> ind = (ILArray <Int64>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <Int32> ) { ILArray <Int32> ind = (ILArray <Int32>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <Int16> ) { ILArray <Int16> ind = (ILArray <Int16>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } /* !HC:TYPELIST: * */ } else if (rng is ILArray <float> ) { ILArray <float> ind = (ILArray <float>)rng; tmp = ind.Dimensions.NumberOfElements; indices = new int[tmp]; for (int p = 0; p < tmp; p++) { indices[p] = (int)ind.GetValue(p); } #endregion HYCALPER AUTO GENERATED CODE } else { throw new ILArgumentTypeException("error removing: dimensions specifier must be numeric type!"); } } if (indices == null) { dimensionIdx = 0; dimensions = m_dimensions; indices = new int[0] { }; return; } #endregion } else if (range[i] is Slice) { #region Python slice input Slice rng = (Slice)range[i]; if ((rng != null) && !(rng.start == null && rng.stop == null && rng.step == null)) { dimensionIdx = i; if (specCount++ > 0) { throw new ILArgumentException("Error removing: only one dimension must be non-empty!"); } List <int> ids = new List <int>(); int start, ende, step; if (rng.start == null) { start = 0; } else { start = (int)(rng.start); } if (rng.stop == null) { ende = m_dimensions[i]; } else { ende = (int)(rng.stop) + 1; } if (rng.step == null) { step = 1; } else { step = (int)(rng.step); } try { for (int r = start; r < ende; r += step) { ids.Add(r); } indices = ids.ToArray(); } catch (FormatException e) { throw new ILArgumentException("remove: invalid index in " + i.ToString() + "th dimension! (" + e.Message + ")"); } if (indices == null) { dimensionIdx = 0; dimensions = m_dimensions; indices = new int[0] { }; return; } } #endregion } else if (range is string[]) { #region string input string rng = (string)range[i]; if (rng.Contains(";")) { throw new ILArgumentException("Error removing: ';' not valid"); } if (rng != null && rng.Trim() != ":") { dimensionIdx = i; if (specCount++ > 0) { throw new ILArgumentException("Error removing: only one dimension must be non-empty!"); } rng = rng.Replace("end", (m_dimensions[i] - 1).ToString()); string[] tmpIdx = rng.Split(','); List <int> ids = new List <int>(); try { for (int c = 0; c < tmpIdx.Length; c++) { string[] tmprng = tmpIdx[c].Split(':'); switch (tmprng.Length) { case 1: // no range spec. ids.Add(int.Parse(tmprng[0].Trim())); break; case 2: // single range: spacing 1 int start = int.Parse(tmprng[0].Trim()); int ende = int.Parse(tmprng[1].Trim()) + 1; for (int r = start; r < ende; r++) { ids.Add(r); } break; case 3: // single range: spacing 1 start = int.Parse(tmprng[0].Trim()); ende = int.Parse(tmprng[2].Trim()) + 1; int step = int.Parse(tmprng[1].Trim()); for (int r = start; r < ende; r += step) { ids.Add(r); } break; } } indices = ids.ToArray(); } catch (FormatException e) { throw new ILArgumentException("remove: invalid index in " + i.ToString() + "th dimension! Did you seperate dimensions by ';'? (" + e.Message + ")"); } } if (indices == null) { dimensionIdx = 0; dimensions = m_dimensions; indices = new int[0] { }; return; } #endregion } else { throw new ILArgumentException("Invalid range specification. The type of indices specified is invalid. Remove failed."); } } // check if array must be reshaped int[] tmpDim = new int[(inDimCount > 1) ? inDimCount : 2]; int pos = 0; while (pos < m_dimensions.NumberOfDimensions) { if (pos < inDimCount) { tmpDim[pos] = m_dimensions[pos]; } else { int mult = 1; int i = pos; while (i < m_dimensions.NumberOfDimensions) { mult *= m_dimensions[i++]; } tmpDim[pos - 1] *= mult; break; } pos++; } // if only one dimension specified -> make row vector if (pos == 1) { tmpDim[1] = tmpDim[0]; tmpDim[0] = 1; dimensionIdx = 1; } dimensions = new ILDimension(tmpDim); }
/// <summary> /// Number of elements of A /// </summary> /// <param name="A">input array</param> /// <returns>number of elements of A</returns> /// <remarks>this is an alias/abreviation for A.Dimensions.NumberOfElements</remarks> public static int numel(ILBaseArray A) { if (object.Equals(A,null)) return 0; return A.Dimensions.NumberOfElements; }
/// <summary> /// Number of dimensions of A /// </summary> /// <param name="A">input array</param> /// <returns>if A is null: 0 - else number of dimensions of A</returns> /// <remarks>this is an alias/abreviation for A.Dimensions.NumberOfDimensions</remarks> /// public static int ndims(ILBaseArray A) { if (object.Equals(A,null)) return 0; return A.Dimensions.NumberOfDimensions; }
/// <summary> /// longest dimension of A /// </summary> /// <param name="A">input array</param> /// <returns>if A is null:0 - length of longest dimension of A</returns> /// <remarks>this is an alias/abreviation for A.Dimensions.Longest</remarks> public static int length(ILBaseArray A) { if (object.Equals(A,null)) return 0; return A.Dimensions.Longest; }
/// <summary> /// add array to collection of arrays in this ILMatFile container /// </summary> /// <param name="A">array to be added to ILMatFile</param> /// <returns>string used to identify the array in the collection of arrays</returns> /// <remarks><para>The internal <code>Name</code> property of array given will be used as identification key.</para> /// <para>Note, the test if elements of A are supported by MatFile specification is done if the MatFile is to be written to stream ('write').</para></remarks> /// <exception cref="ILNumerics.Exceptions.ILInvalidOperationException"> if the internal name of A does not fullfill the restrictions given by Matlab.</exception> public string Add(ILBaseArray A) { this[A.Name] = A; return A.Name; }
/// <summary> /// Create MatFile object from ILBaseArray /// </summary> /// <param name="input">ILBaseArray of arbitrary size/type</param> /// <exception cref="ArgumentNullException"> if input array was null or one of the names in the input arrays does not fullfill the restrictions made from Matlab</exception> public ILMatFile(ILBaseArray[] input) { if (object.Equals(input,null)) throw new ArgumentNullException ("input array may not be null!"); m_data = new Dictionary<string,ILBaseArray> (input.Length); for (int i=0; i < input.Length; i++) { this[input[i].Name] = input[i]; } }
public static bool isequal(ILBaseArray A, ILBaseArray B) { return A.Equals(B); }