/// <summary>
/// Subarray access for get/set/removal
/// </summary>
/// <param name="slices">Array of IronPython Slice objects</param>
/// <returns>Reference pointing to the elements of this array specified by range. If used for removal:
/// the array will be changed to a referencing array having the selected parts removed.</returns>
public ILArray <BaseT> this[params IronPython.Runtime.Slice[] slices]
{
get
{
return((ILArray <BaseT>)SubarrayPython((object[])slices));
}
set
{
if (Object.ReferenceEquals(value, null) || value.IsEmpty)
{
ILDimension oldDim = m_dimensions;
ILDimension newdim = null;
int dimIdx = -1;
int[] indices = null;
ExtractRemovalParameter((object[])slices, out dimIdx, out indices, out newdim);
if (indices.Length == 0)
{
return;
}
Reshape(newdim);
try {
Remove(dimIdx, indices);
} catch (ILException e) {
// rollback:
Reshape(oldDim);
throw e;
}
}
else
{
SetRange(new ILRange(m_dimensions, RangeSide.Left, (object[])slices), value);
}
}
}
/// <summary>
/// output information about this ILLogicalArray
/// </summary>
/// <param name="s">predefined string, to be used as prefix for output</param>
/// <param name="maxLength">number of characters in lines of output</param>
/// <returns>string representation of this ILLogicalArray</returns>
public override String ToString(String s, int maxLength)
{
StringBuilder sb = new StringBuilder(s);
// print dimension string
ILDimension dim = Dimensions;
sb.Append(String.Format("\r\nILLogicalArray: '{0}'\r\n",
(Name.Length > 0) ? Name : this.GetHashCode().ToString()));
sb.Append("[");
for (int t = 0; t < dim.NumberOfDimensions; t++)
{
sb.Append(dim[t]);
if (t < dim.NumberOfDimensions - 1)
{
sb.Append(",");
}
}
sb.Append("] ");
// status flags
if (IsReference)
{
sb.Append("Ref(" + GetNumberOfReferences() + ") ");
}
else
{
sb.Append("Phys. ");
}
sb.Append(ValuesToString(maxLength));
return(sb.ToString());
}
public ILArray(IronPython.Runtime.List list)
{
List <int> size = new List <int>();
Type type = typeof(double);
PythonListHelper.GetListDimensionsAndType(ref size, list, ref type);
if (!PythonListHelper.CheckList(ref size, list, 0, ref type))
{
throw new ArgumentException("List is not rectangular or not of constant type!");
}
if (type != typeof(BaseT))
{
throw new ArgumentException("Array type does not match list type!");
}
try
{
m_dimensions = new ILDimension(true, size.ToArray());
bool dummy;
m_data = ILMemoryPool.Pool.New <BaseT>(m_dimensions.NumberOfElements, true, out dummy);
m_name = "";
IncreaseReference();
}
catch (Exception e)
{
throw new Exception("Error creating new ILArray object.", e);
}
int[] indices = new int[size.Count];
FillILArrayFromList <BaseT>(ref size, list, 0, ref type, ref m_data, 0, 1);
}
/*!HC:TYPELIST:
* <hycalper>
* <type>
* <source locate="after">
* inArr1
* </source>
* <destination>byte</destination>
* <destination>complex</destination>
* <destination>complex</destination>
* <destination>double</destination>
* </type>
* <type>
* <source locate="after">
* inCls1
* </source>
* <destination><![CDATA[ILArray<byte>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* <destination><![CDATA[ILArray<double>]]></destination>
* </type>
* <type>
* <source locate="after">
* outCls1
* </source>
* <destination><![CDATA[ILArray<byte>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* <destination><![CDATA[ILArray<double>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* </type>
* <type>
* <source locate="after">
* outArr1
* </source>
* <destination>byte</destination>
* <destination>complex</destination>
* <destination>double</destination>
* <destination>complex</destination>
* </type>
* <type>
* <source locate="after">
* delegate_unary
* </source>
* <destination>ILByteFunctionByte</destination>
* <destination>ILComplexFunctionComplex</destination>
* <destination>ILDoubleFunctionComplex</destination>
* <destination>ILComplexFunctionDouble</destination>
* </type>
* <type>
* <source locate="after">
* unaryop
* </source>
* <destination>ByteOperatorByte</destination>
* <destination>ComplexOperatorComplex</destination>
* <destination>DoubleOperatorComplex</destination>
* <destination>ComplexOperatorDouble</destination>
* </type>
* </hycalper>
*/
/// <summary>
/// Applys the function (delegate) given to all elements of the storage
/// </summary>
/// <param name="inArray">storage array to apply the function to</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns>new <![CDATA[ /*!HC:outCls1*/ ILArray<double> ]]> with result of operation</returns>
/// <remarks> the values of inArray will not be altered.</remarks>
private static /*!HC:outCls1*/ ILArray <double> /*!HC:unaryop*/ DoubleOperatorDouble(/*!HC:inCls1*/ ILArray <double> inArray,
/*!HC:delegate_unary*/ ILDoubleFunctionDouble operation)
{
ILDimension inDim = inArray.Dimensions;
/*!HC:outArr1*/ double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retDblArr = new /*!HC:outArr1*/ double [newLength];
int leadDimLen = inDim [0];
unsafe
{
fixed(/*!HC:outArr1*/ double *pOutArr = retDblArr)
fixed(/*!HC:inArr1*/ double *pInArr = inArray.m_data)
{
/*!HC:outArr1*/ double *lastElement = pOutArr + retDblArr.Length;
/*!HC:outArr1*/ double *tmpOut = pOutArr;
/*!HC:inArr1*/ double * tmpIn = pInArr;
while (tmpOut < lastElement)
{
*tmpOut++ = operation(*tmpIn++);
}
}
}
return(new /*!HC:outCls1*/ ILArray <double> (retDblArr, inDim.ToIntArray()));
}
/// <summary>
/// normal random distributed n-dimensional array elements
/// </summary>
/// <param name="dimensions">int array or single int paramters specifying
/// dimensions for new array to be created</param>
/// <returns>n-dimensional array filled with random numbers.</returns>
/// <remarks>the elements lay within the range 0.0 ... 1.0 and are choosen to be normally
/// distributed.</remarks>
public static ILArray <double> randn(params int[] dimensions)
{
ILDimension dim;
if (dimensions.Length == 1)
{
dim = new ILDimension(dimensions[0], dimensions[0]);
}
else
{
dim = new ILDimension(dimensions);
}
if (m_nrandomGenerator == null)
{
m_nrandomGenerator = new ILNRandom(Environment.TickCount);
}
double[] data = ILMemoryPool.Pool.New <double>(dim.NumberOfElements);
unsafe
{
fixed(double *pRetArray = data)
{
double *pCurIdx = pRetArray;
double *pLastElement = pCurIdx + dim.NumberOfElements;
while (pCurIdx < pLastElement)
{
*pCurIdx++ = m_nrandomGenerator.NextDouble();
}
}
}
return(new ILArray <double>(data, dim));
}
/// <summary>
/// create physical copy from this physical array and shift dimensions
/// </summary>
/// <param name="indices">sequential indices. may be of any size</param>
/// <param name="shift">number of dimensions to shift the result</param>
/// <returns>physical copy of elements addressed by indices.shape of shifted indices</returns>
private ILArray <BaseT> CreatePhysicalSubarrayFromPhysicalSequentialShifted(ILArray <byte> indices, int shift)
{
if (shift < 0)
{
shift = 0;
}
if (shift > indices.m_dimensions.NumberOfDimensions)
{
shift %= indices.m_dimensions.NumberOfDimensions;
}
ILDimension dim = indices.m_dimensions.GetShifted(shift);
int outLen = dim.NumberOfElements;
BaseT[] outdata = ILMemoryPool.Pool.New <BaseT> (outLen--);
int outPos = 0, outInc = dim.SequentialIndexDistance(dim.NumberOfDimensions - shift);
byte [] indData = indices.m_data;
for (int i = 0; i < outLen; i++)
{
outdata[outPos] = m_data[(int)indData[i]];
outPos += outInc;
if (outPos > outLen)
{
outPos %= outLen;
}
}
outdata[outLen] = m_data[(int)indData[outLen]];
return(new ILArray <BaseT>(outdata, dim));
}
/// <summary>
/// Applys the function (delegate) given to all elements of the storage
/// </summary>
/// <param name="inArray">storage array to apply the function to</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns>new <![CDATA[ ILArray<complex> ]]> with result of operation</returns>
/// <remarks> the values of inArray will not be altered.</remarks>
private static ILArray <complex> ComplexOperatorComplex(ILArray <complex> inArray,
ILComplexFunctionComplex operation)
{
ILDimension inDim = inArray.Dimensions;
complex [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retDblArr = new complex [newLength];
int leadDimLen = inDim [0];
unsafe
{
fixed(complex *pOutArr = retDblArr)
fixed(complex * pInArr = inArray.m_data)
{
complex *lastElement = pOutArr + retDblArr.Length;
complex *tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement)
{
*tmpOut++ = operation(*tmpIn++);
}
}
}
return(new ILArray <complex> (retDblArr, inDim.ToIntArray()));
}
/// <summary>
/// Applys the function (delegate) given to all elements of the storage
/// </summary>
/// <param name="inArray">storage array to apply the function to</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns>new <![CDATA[ ILArray<byte> ]]> with result of operation</returns>
/// <remarks> the values of inArray will not be altered.</remarks>
private static ILArray <byte> ByteOperatorByte(ILArray <byte> inArray,
ILByteFunctionByte operation)
{
ILDimension inDim = inArray.Dimensions;
byte [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retDblArr = new byte [newLength];
int leadDimLen = inDim [0];
unsafe
{
fixed(byte *pOutArr = retDblArr)
fixed(byte *pInArr = inArray.m_data)
{
byte *lastElement = pOutArr + retDblArr.Length;
byte *tmpOut = pOutArr;
byte *tmpIn = pInArr;
while (tmpOut < lastElement)
{
*tmpOut++ = operation(*tmpIn++);
}
}
}
return(new ILArray <byte> (retDblArr, inDim.ToIntArray()));
}
/// <summary>
/// Constructor creating ILLogicalArray, predefined storage (fast version)
/// </summary>
/// <param name="data">predefined storage elements. The array will directly be used
/// as underlying storage. No copy will be made! </param>
/// <param name="dimension">Dimensions specification.</param>
/// <param name="nonZeroCount">number of nonzero elements in <paramref name="data"/>.
/// Providing this parameter prevents from counting the 'true' elements (again). </param>
public ILLogicalArray(byte[] data, ILDimension dimension, int nonZeroCount)
: base(data, dimension)
{
if (nonZeroCount < 0)
{
throw new ILNumerics.Exceptions.ILArgumentException("invalid number of non-zero-elements given!");
}
m_numberNonZero = nonZeroCount;
}
/// <summary>
/// Create N-dimensional array with elements counting from 1.
/// </summary>
/// <param name="dimensions">Variable int array with dimension specification</param>
/// <returns>Array with elements counting from 1 ... dimensions.NumberOfElements</returns>
/// <remarks>This function may be used for the convenient creation of arrays for testing purposes.</remarks>
public static ILArray <double> counter(params int[] dimensions)
{
ILDimension dimRet = new ILDimension(dimensions);
double [] retArr = ILMemoryPool.Pool.New <double>(dimRet.NumberOfElements);
for (int i = 0; i < retArr.Length;)
{
retArr[i] = ++i;
}
return(new ILArray <double>(retArr, dimRet));
}
/// <summary>
/// Dimension represented by this ILIndexOffset
/// </summary>
/// <returns>Dimension object</returns>
/// <remarks>This function will introduce a performance penalty,
/// since the dimension object will get reconstructed every time called.
/// One should therefore cache the dimension externally, if needed.</remarks>
public ILDimension GetDimensions()
{
ILDimension ret;
int[] dims = new int[m_idxOffset.Length];
for (int d = m_idxOffset.Length; d-- > 0;)
{
dims[d] = m_idxOffset[d].Length;
}
ret = new ILDimension(dims);
return(ret);
}
/// <summary>
/// Create ILArray of specified size and type
/// </summary>
/// <param name="data">preallocated array with data. The array will
/// directly be used for storage. No copy will be done.</param>
/// <param name="dimensions">
/// dimension specification. The ILDimension given must not be null and will
/// directly be used for the new object! No copy will be made for it!
/// </param>
/// <remarks>The size parameter may not be null or empty!
/// An exception will be thrown in this case. The dimensions will be trimmed
/// before processing (removing non singleton dimensions from the end).
/// Depending on the requested size an ILArray of the specified type and
/// dimension will be created.
/// </remarks>
public ILArray(BaseT[] data, ILDimension dimensions)
{
System.Diagnostics.Debug.Assert(dimensions != null, "ILArray|(construct): " +
"dimension must be specified!");
m_dimensions = dimensions.Trim();
if (data.Length != m_dimensions.NumberOfElements)
{
throw new ILArgumentException("ILArray.construct: Data array specifier must match "
+ "size of dimensions!");
}
m_data = data;
}
/// <summary>
/// Create array innitialized with ones
/// </summary>
/// <param name="type">Numeric type specification. One value out of the types listed in the <see cred="ILNumerics.NumericType"/>
/// enum.</param>
/// <param name="dimensions">Dimension specification. At least one dimension must be specified.</param>
/// <returns>ILArray<BaseT> of inner type corresponding to <paramref name="type"/> argument.</returns>
/// <remarks>The array returned may be casted to the actual type accordingly afterwards.
/// <para>
/// <list type="number">
/// <listheader>The following types are supported: </listheader>
/// <item>Double</item>
/// <item>Single</item>
/// <item>Complex</item>
/// <item>FComplex</item>
/// <item>Byte</item>
/// <item>Char</item>
/// <item>Int16</item>
/// <item>Int32</item>
/// <item>Int64</item>
/// <item>UInt16</item>
/// <item>UInt32</item>
/// <item>UInt64</item>
/// </list>
/// </para>
/// </remarks>
public static ILBaseArray ones(NumericType type, params int[] dimensions)
{
if (dimensions.Length < 1)
{
throw new ILArgumentException("ones: invalid dimension specified!");
}
switch (type)
{
case NumericType.Double:
return(ones(dimensions));
case NumericType.Complex:
ILDimension dim = new ILDimension(dimensions);
unsafe {
complex[] data = null;
data = new complex[dim.NumberOfElements];
fixed(complex *pD = data)
{
complex *pStart = pD;
complex *pEnd = pD + data.Length;
while (pEnd > pStart)
{
*(--pEnd) = new complex(1.0, 1.0);
}
}
return(new ILArray <complex>(data, dimensions));
}
case NumericType.Byte:
dim = new ILDimension(dimensions);
unsafe {
byte[] data = null;
data = new byte[dim.NumberOfElements];
fixed(byte *pD = data)
{
byte *pStart = pD;
byte *pEnd = pD + data.Length;
while (pEnd > pStart)
{
*(--pEnd) = 1;
}
}
return(new ILArray <byte>(data, dimensions));
}
}
return(null);
}
/// <summary>
/// invert elements of A, return result as out argument
/// </summary>
/// <param name="A"></param>
/// <param name="outArray"></param>
public static void /*!HC:HCFuncName*/ invert(/*!HC:inCls1*/ ILArray <double> A, /*!HC:inCls2*/ ILArray <double> outArray)
{
#region array + array
ILDimension inDim = A.Dimensions;
if (!inDim.IsSameSize(outArray.Dimensions))
{
throw new ILDimensionMismatchException();
}
int leadDim = 0, leadDimLen = inDim [0];
// walk along the longest dimension (for performance reasons)
for (int i = 1; i < inDim.NumberOfDimensions; i++)
{
if (leadDimLen < inDim [i])
{
leadDimLen = inDim [i];
leadDim = i;
}
}
unsafe
{
fixed(/*!HC:inArr1*/ double *inA1 = A.m_data)
fixed(/*!HC:inArr2*/ double *inA2 = outArray.m_data)
{
/*!HC:inArr1*/ double *pInA1 = inA1;
/*!HC:inArr2*/ double *pInA2 = inA2;
int c = 0;
/*!HC:inArr2*/ double *outEnd = inA2 + outArray.m_data.Length;
if (A.IsReference)
{
while (pInA2 < outEnd) //HC07
/*!HC:HCCompute07*/
{
*pInA2++ = /*!HC:outCast*/ /**/ (*(pInA1 + A.getBaseIndex(c++)) /*!HC:HCoperation*/ * -1.0);
}
}
else
{
while (pInA2 < outEnd) //HC11
/*!HC:HCCompute11*/
{
*pInA2++ = /*!HC:outCast*/ /**/ (*pInA1++ /*HC:HCoperation*/ *(-1.0));
}
}
}
#endregion array + array
}
return;
}
/// <summary>
/// invert elements of A, return result as out argument
/// </summary>
/// <param name="A"></param>
/// <param name="outArray"></param>
public static void invert(ILArray <complex> A, ILArray <complex> outArray)
{
#region array + array
ILDimension inDim = A.Dimensions;
if (!inDim.IsSameSize(outArray.Dimensions))
{
throw new ILDimensionMismatchException();
}
int leadDim = 0, leadDimLen = inDim [0];
// walk along the longest dimension (for performance reasons)
for (int i = 1; i < inDim.NumberOfDimensions; i++)
{
if (leadDimLen < inDim [i])
{
leadDimLen = inDim [i];
leadDim = i;
}
}
unsafe
{
fixed(complex *inA1 = A.m_data)
fixed(complex * inA2 = outArray.m_data)
{
complex *pInA1 = inA1;
complex *pInA2 = inA2;
int c = 0;
complex *outEnd = inA2 + outArray.m_data.Length;
if (A.IsReference)
{
while (pInA2 < outEnd) //HC07
{
*pInA2++ = (*(pInA1 + A.getBaseIndex(c++)) * (-1.0));
}
}
else
{
while (pInA2 < outEnd) //HC11
{
*pInA2++ = (*pInA1++ /*HC:*/ *(-1.0));
}
}
}
#endregion array + array
}
return;
}
/// <summary>
/// Create ILArray of type object and given name and size
/// </summary>
/// <param name="size">
/// Variable length int array specifying the number and size of dimensions
/// to be created.
/// </param>
/// <remarks>The size parameter may not be null or an empty array!
/// An Exception will be thrown in this case. The dimensions will be trimmed
/// before processing (removing non singleton dimensions from the end).
/// Depending on the requested size an ILArray of the specified
/// dimension will be created.
/// </remarks>
public ILArray(params int[] size)
{
if (size == null || size.Length == 0)
{
throw new ArgumentException("ILArray|(construct): dimension specification needed!");
}
try {
m_dimensions = new ILDimension(true, size);
bool dummy;
m_data = ILMemoryPool.Pool.New <BaseT>(m_dimensions.NumberOfElements, true, out dummy);
m_name = "";
} catch (Exception e) {
throw new Exception("Error creating new ILArray object.", e);
}
}
/// <summary>
/// create physical copy from this physical array
/// </summary>
/// <param name="indices">sequential indices. may be of any size</param>
/// <returns>physical copy of elements addressed by indices.shape of indices</returns>
private ILArray <BaseT> CreatePhysicalSubarrayFromPhysicalSequential(ILArray <byte> indices)
{
ILDimension dim = indices.m_dimensions;
int outLen = dim.NumberOfElements;
BaseT[] outdata = ILMemoryPool.Pool.New <BaseT> (outLen);
byte [] indData = indices.m_data;
for (int i = 0; i < outLen; i++)
{
outdata[i] = m_data[(int)indData[i]];
}
return(new ILArray <BaseT>(outdata, dim));
}
/// <summary>
/// Create ILArray of specified size and type
/// </summary>
/// <param name="size">
/// Variable length integer array specifying the number and size of dimensions
/// to be created.
/// </param>
/// <param name="data">preallocated array with data. The array will
/// directly be used for storage. No copy will be done.</param>
/// <remarks>The size parameter may not be null or empty!
/// An exception will be thrown in this case. The dimensions will be trimmed
/// before processing (removing non singleton dimensions from the end).
/// Depending on the requested size an ILArray of the specified type and
/// dimension will be created.
/// </remarks>
public ILArray(BaseT[] data, params int[] size)
{
if (size == null || size.Length == 0)
{
m_dimensions = new ILDimension(1, data.Length);
}
else
{
m_dimensions = new ILDimension(true, size);
}
if (data.Length != m_dimensions.NumberOfElements)
{
throw new ILArgumentException("size of data must match dimensions!");
}
m_data = data;
}
/// <summary>
/// create scalar or row vector from values explitely given
/// </summary>
/// <param name="vector_elements">elements. </param>
/// <remarks><para>The elements may are given as comma seperated list or as predefined System.Array
/// of type 'BaseT'. In this case the System.Array object given will directly be used as storage
/// for the newly created ILArray.</para>
/// <para>If vector_elements is null, an empty ILArray will be created.</para></remarks>
public ILArray(BaseT[] vector_elements)
{
if (object.Equals(vector_elements, null))
{
m_data = new BaseT[0];
m_dimensions = new ILDimension(new int[2] {
0, 0
});
}
else
{
m_data = vector_elements;
m_dimensions = new ILDimension(new int[2] {
1, m_data.Length
});
}
}
////////////////////////////// ONES / ZEROS ... ////////////////////////////////
public static ILArray <double> Ones(params int[] dimensions)
{
ILDimension dim = new ILDimension(dimensions);
double[] data = new double[dim.NumberOfElements];
ILArray <double> ret = new ILArray <double>(data, dimensions);
return(Set(ret, 1.0));
{ /* unsafe {
* fixed(double* pData = data) {
* double* ende = pData + data.Length;
* double* curr = pData;
* while (curr < ende)
* curr++ = 1.0;
* }*/
}
}
/// <summary>
/// random n-dimensional array elements
/// </summary>
/// <param name="dimensions">int array or single int paramters specifying
/// dimensions for new array to be created</param>
/// <returns>n-dimensional array filled with random numbers.</returns>
/// <remarks>the elements lay within the range 0.0 ... 1.0 and are uniformly
/// distributed.</remarks>
public static ILArray <double> Rand(params int[] dimensions)
{
ILDimension dim = new ILDimension(dimensions);
double[] data = new double[dim.NumberOfElements];
unsafe
{
fixed(double *pRetArray = data)
{
double *pCurIdx = pRetArray;
double *pLastElement = pCurIdx + dim.NumberOfElements;
Random r = new Random((int)System.Environment.TickCount);
while (pCurIdx < pLastElement)
{
*pCurIdx++ = r.NextDouble();
}
}
}
return(new ILArray <double>(data, dimensions));
}
/// <summary>
/// Create N-dimensional array with elements counting from 1 and specified interval.
/// </summary>
/// <param name="start">Initial value.</param>
/// <param name="increment">Increment for each element.</param>
/// <param name="dimensions">Variable int array with dimension specification.</param>
/// <returns>Array with elements counting from 1 ... dimensions.NumberOfElements.</returns>
/// <remarks><para>Counter is a fast alternative to the creation of arrays via <see cref="ILNumerics.BuiltInFunctions.ILMath.ones(int[])"/>
/// or <see cref="ILNumerics.BuiltInFunctions.ILMath.zeros(int[])"/> with subsequent modification.
/// Counter is more general. It can create arrays of all constants (zeros, ones, twos ...) if <paramref name="increment"/> is 0, regularly
/// incrementing elements if <paramref name="increment"/> is positive or negative.</para>
/// This function may also be used for the convenient creation of arrays for testing purposes.
/// <para>Keep in mind: in order to distingush this function from the overloaded version <see cref="ILNumerics.BuiltInFunctions.ILMath.counter(int[])"/>
/// you need to specify parameters <paramref name="start"/> and <paramref name="increments"/> explicitly as double value:</para>
/// <example><code>
/// // This will create elements counting from 1...24:
/// <![CDATA[ILArray<double>]]> A = ILMath.counter(4,3,2);
/// // This will create elements counting from 1...48 with intervals of 2.0:
/// <![CDATA[ILArray<double>]]> A = ILMath.counter(1.0,2.0,4,3,2);
/// // ... but this will (by mistake) call the wrong function:
/// <![CDATA[ILArray<double>]]> A = ILMath.counter(1,2,4,3,2);
/// // ... and therefore create an array of size [1,2,4,3,2] with elements counting from one!
/// </code></example> </remarks>
public static ILArray <double> counter(double start, double increment, params int[] dimensions)
{
ILDimension dimRet = new ILDimension(dimensions);
double [] retArr = ILMemoryPool.Pool.New <double>(dimRet.NumberOfElements);
double val = start;
unsafe
{
fixed(double *pRetArr = retArr)
{
double *pRetArray = pRetArr;
double *pEnd = pRetArr + retArr.Length;
while (pRetArray < pEnd)
{
*pRetArray++ = val;
val += increment;
}
}
}
return(new ILArray <double>(retArr, dimRet));
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>
/// invert elements of A, return result as out argument
/// </summary>
/// <param name="A"></param>
/// <param name="outArray"></param>
public static void invert(ILArray <byte> A, ILArray <byte> outArray)
{
#region array + array
ILDimension inDim = A.Dimensions;
if (!inDim.IsSameSize(outArray.Dimensions))
{
throw new ILDimensionMismatchException();
}
int leadDim = 0, leadDimLen = inDim [0];
// walk along the longest dimension (for performance reasons)
for (int i = 1; i < inDim.NumberOfDimensions; i++)
{
if (leadDimLen < inDim [i])
{
leadDimLen = inDim [i];
leadDim = i;
}
}
unsafe
{
fixed(byte *inA1 = A.m_data)
fixed(byte *inA2 = outArray.m_data)
{
byte *pInA1 = inA1;
byte *pInA2 = inA2;
byte *outEnd = inA2 + outArray.m_data.Length;
while (pInA2 < outEnd) //HC11
{
*pInA2++ = (byte)(*pInA1++ /*HC:*/ *(-1));
}
}
#endregion array + array
}
return;
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>
/// operate on elements of both storages by the given function -> relational operations
/// </summary>
/// <param name="inArray1">First storage array</param>
/// <param name="inArray2">Second storage array</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns><![CDATA[ ILArray<complex> ]]> with result of operation for corresponding
/// elements of both arrays.</returns>
/// <remarks>The values of inArray1 nor inArray2 will not be altered.The dimensions
/// of both arrays must match.</remarks>
private static ILArray <complex> ComplexOperatorComplexComplex(ILArray <complex> inArray1, ILArray <complex> inArray2,
ILComplexFunctionComplexComplex operation)
{
ILDimension inDim = inArray1.Dimensions;
if (!inDim.IsSameSize(inArray2.Dimensions))
{
throw new ILDimensionMismatchException();
}
complex [] retSystemArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retSystemArr = new complex [newLength];
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(complex *pInArr1 = inArray1.m_data)
fixed(complex * pInArr2 = inArray2.m_data)
fixed(complex * pOutArr = retSystemArr)
{
complex *poutarr = pOutArr;
complex *poutend = poutarr + newLength;
complex *pIn1 = pInArr1;
complex *pIn2 = pInArr2;
while (poutarr < poutend)
{
*poutarr++ = operation(*pIn1++, *pIn2++);
}
}
}
return(new ILArray <complex> (retSystemArr, inDim.ToIntArray()));
}
/// <summary>
/// operate on elements of both storages by the given function -> relational operations
/// </summary>
/// <param name="inArray1">First storage array</param>
/// <param name="inArray2">Second storage array</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns><![CDATA[ ILArray<byte> ]]> with result of operation for corresponding
/// elements of both arrays.</returns>
/// <remarks>The values of inArray1 nor inArray2 will not be altered.The dimensions
/// of both arrays must match.</remarks>
private static ILArray <byte> ByteOperatorByteByte(ILArray <byte> inArray1, ILArray <byte> inArray2,
ILByteFunctionByteByte operation)
{
ILDimension inDim = inArray1.Dimensions;
if (!inDim.IsSameSize(inArray2.Dimensions))
{
throw new ILDimensionMismatchException();
}
byte [] retSystemArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retSystemArr = new byte [newLength];
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(byte *pInArr1 = inArray1.m_data)
fixed(byte *pInArr2 = inArray2.m_data)
fixed(byte *pOutArr = retSystemArr)
{
byte *poutarr = pOutArr;
byte *poutend = poutarr + newLength;
byte *pIn1 = pInArr1;
byte *pIn2 = pInArr2;
while (poutarr < poutend)
{
*poutarr++ = operation(*pIn1++, *pIn2++);
}
}
}
return(new ILArray <byte> (retSystemArr, inDim.ToIntArray()));
}
/*!HC:TYPELIST:
* <hycalper>
* <type>
* <source locate="after">
* inArr1
* </source>
* <destination>byte</destination>
* <destination>complex</destination>
* </type>
* <type>
* <source locate="after">
* inArr2
* </source>
* <destination>byte</destination>
* <destination>complex</destination>
* </type>
* <type>
* <source locate="after">
* inCls1
* </source>
* <destination><![CDATA[ILArray<byte>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* </type>
* <type>
* <source locate="after">
* inCls2
* </source>
* <destination><![CDATA[ILArray<byte>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* </type>
* <type>
* <source locate="after">
* outCls1
* </source>
* <destination><![CDATA[ILArray<byte>]]></destination>
* <destination><![CDATA[ILArray<complex>]]></destination>
* </type>
* <type>
* <source locate="after">
* outArr1
* </source>
* <destination>byte</destination>
* <destination>complex</destination>
* </type>
* <type>
* <source locate="after">
* delegate_binary
* </source>
* <destination>ILByteFunctionByteByte</destination>
* <destination>ILComplexFunctionComplexComplex</destination>
* </type>
* <type>
* <source locate="after">
* hcfunctionName
* </source>
* <destination>ByteOperatorByteByte</destination>
* <destination>ComplexOperatorComplexComplex</destination>
* </type>
* </hycalper>
*/
/// <summary>
/// operate on elements of both storages by the given function -> relational operations
/// </summary>
/// <param name="inArray1">First storage array</param>
/// <param name="inArray2">Second storage array</param>
/// <param name="operation">operation to apply to the elements of inArray. This
/// acts like a function pointer.</param>
/// <returns><![CDATA[ /*!HC:outCls1*/ ILArray<double> ]]> with result of operation for corresponding
/// elements of both arrays.</returns>
/// <remarks>The values of inArray1 nor inArray2 will not be altered.The dimensions
/// of both arrays must match.</remarks>
private static /*!HC:outCls1*/ ILArray <double> /*!HC:hcfunctionName*/ DoubleOperatorDoubleDouble(/*!HC:inCls1*/ ILArray <double> inArray1, /*!HC:inCls2*/ ILArray <double> inArray2,
/*!HC:delegate_binary*/ ILDoubleFunctionDoubleDouble operation)
{
ILDimension inDim = inArray1.Dimensions;
if (!inDim.IsSameSize(inArray2.Dimensions))
{
throw new ILDimensionMismatchException();
}
/*!HC:outArr1*/ double [] retSystemArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retSystemArr = new /*!HC:outArr1*/ double [newLength];
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(/*!HC:inArr1*/ double *pInArr1 = inArray1.m_data)
fixed(/*!HC:inArr2*/ double *pInArr2 = inArray2.m_data)
fixed(/*!HC:outArr1*/ double *pOutArr = retSystemArr)
{
/*!HC:outArr1*/ double *poutarr = pOutArr;
/*!HC:outArr1*/ double *poutend = poutarr + newLength;
/*!HC:inArr1*/ double * pIn1 = pInArr1;
/*!HC:inArr2*/ double * pIn2 = pInArr2;
while (poutarr < poutend)
{
*poutarr++ = operation(*pIn1++, *pIn2++);
}
}
}
return(new /*!HC:outCls1*/ ILArray <double> (retSystemArr, inDim.ToIntArray()));
}
/// <summary>Exponential of array elements </summary>
/// <param name="A">input array</param>
/// <returns>Exponential of array elements</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILArray <double> exp(ILArray <double> A)
{
if (A.IsEmpty)
{
return(ILArray <double> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new double [newLength];
retDblArr = ILMemoryPool.Pool.New <double> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(double *pOutArr = retDblArr)
fixed(double *pInArr = A.m_data)
{
double *lastElement = pOutArr + retDblArr.Length;
double *tmpOut = pOutArr;
double *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = Math.Exp(*tmpIn++);
}
}
}
return(new ILArray <double> (retDblArr, inDim));
}
/// <summary>Finds finite value elements</summary>
/// <param name="A">input array</param>
/// <returns>Logical array with 1 if the corresponding elements of input array is finite, 0 else.</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILLogicalArray isfinite(ILArray <complex> A)
{
if (A.IsEmpty)
{
return(ILLogicalArray.empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
byte [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new byte [newLength];
retDblArr = ILMemoryPool.Pool.New <byte> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(byte *pOutArr = retDblArr)
fixed(complex * pInArr = A.m_data)
{
byte * lastElement = pOutArr + retDblArr.Length;
byte * tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = complex.IsFinite(*tmpIn++) ?(byte)1:(byte)0;
}
}
}
return(new ILLogicalArray(retDblArr, inDim));
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>Hyperbolic tangent of array elements</summary>
/// <param name="A">input array</param>
/// <returns>Hyperbolic tangent of array elements</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static ILArray <complex> tanh(ILArray <complex> A)
{
if (A.IsEmpty)
{
return(ILArray <complex> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
complex [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new complex [newLength];
retDblArr = ILMemoryPool.Pool.New <complex> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(complex *pOutArr = retDblArr)
fixed(complex * pInArr = A.m_data)
{
complex *lastElement = pOutArr + retDblArr.Length;
complex *tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
{
*tmpOut++ = complex.Tanh(*tmpIn++);
}
}
}
return(new ILArray <complex> (retDblArr, inDim));
}
/// <summary>
/// Sinus of array elements
/// </summary>
/// <param name="A">input array</param>
/// <returns>Sinus of elements from input array</returns>
/// <remarks><para>If the input array is empty, an empty array will be returned.</para>
/// <para>The array returned will be a dense array.</para></remarks>
public static /*!HC:outCls*/ ILArray <double> /*!HC:HCfuncname*/ sin(/*!HC:inCls1*/ ILArray <double> A)
{
if (A.IsEmpty)
{
return /*!HC:outCls*/ (ILArray <double> .empty(A.Dimensions));
}
ILDimension inDim = A.Dimensions;
/*!HC:outArr*/ double [] retDblArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
//retDblArr = new /*!HC:outArr*/ double [newLength];
retDblArr = ILMemoryPool.Pool.New </*!HC:outArr*/ double> (newLength);
int leadDimLen = inDim [0];
// physical -> pointer arithmetic
unsafe
{
fixed(/*!HC:outArr*/ double *pOutArr = retDblArr)
fixed(/*!HC:inArr1*/ double *pInArr = A.m_data)
{
/*!HC:outArr*/ double *lastElement = pOutArr + retDblArr.Length;
/*!HC:outArr*/ double *tmpOut = pOutArr;
/*!HC:inArr1*/ double *tmpIn = pInArr;
while (tmpOut < lastElement) // HC02
/*!HC:HCCompute02*/
{
*tmpOut++ = /*!HC:HCoperation*/ Math.Sin(*tmpIn++) /*!HC:HCpostOp*/;
}
}
}
return(new /*!HC:outCls*/ ILArray <double> (retDblArr, inDim));
}
