/// <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>
/// 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;
}
// 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;
}
/// <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()));
}
// 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()));
}
/*!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> sum two arrays elementwise</summary>
/// <param name="A">input 1</param>
/// <param name="B">input 2</param>
/// <returns> Array with elementwise sum of A and B </returns>
/// <remarks><para>On empty input - empty array will be returned.</para>
/// <para>A and / or B may be scalar. The scalar value will operate on all elements of the other arrays in this case.</para>
/// <para>If neither of A or B is scalar or empty, the dimensions of both arrays must match.</para></remarks>
public static ILArray <double> subtract(ILArray <double> A, ILArray <double> B)
{
if (A.IsEmpty)
{
return(ILArray <double> .empty(A.Dimensions));
}
if (B.IsEmpty)
{
return(ILArray <double> .empty(B.Dimensions));
}
if (A.IsScalar)
{
if (B.IsScalar)
{
return(new ILArray <double> (new double [1] {
(A.m_data[0] - B.m_data[0])
}));
}
else
{
#region scalar + array
ILDimension inDim = B.Dimensions;
double [] retArr =
ILMemoryPool.Pool.New <double> (inDim.NumberOfElements);
double scalarValue = A.m_data[0];
unsafe
{
fixed(double *pOutArr = retArr)
fixed(double *pInArr = B.m_data)
{
double *lastElement = pOutArr + retArr.Length;
double *tmpOut = pOutArr;
double *tmpIn = pInArr;
while (tmpOut < lastElement) //HC03
{
*tmpOut++ = (scalarValue - (*tmpIn++));
}
}
}
return(new ILArray <double> (retArr, inDim));
#endregion scalar + array
}
}
else
{
if (B.IsScalar)
{
#region array + scalar
ILDimension inDim = A.Dimensions;
double [] retArr =
ILMemoryPool.Pool.New <double> (A.m_data.Length);
double scalarValue = B.m_data[0];
unsafe
{
fixed(double *pOutArr = retArr)
fixed(double *pInArr = A.m_data)
{
double *lastElement = pOutArr + retArr.Length;
double *tmpOut = pOutArr;
double *tmpIn = pInArr;
while (tmpOut < lastElement) //HC06
{
*tmpOut++ = (*tmpIn++ - scalarValue);
}
}
}
return(new ILArray <double> (retArr, inDim));
#endregion array + scalar
}
else
{
#region array + array
ILDimension inDim = A.Dimensions;
if (!inDim.IsSameSize(B.Dimensions))
{
throw new ILDimensionMismatchException();
}
double [] retSystemArr =
ILMemoryPool.Pool.New <double> (inDim.NumberOfElements);
unsafe
{
fixed(double *pOutArr = retSystemArr)
fixed(double *inA1 = A.m_data)
fixed(double *inA2 = B.m_data)
{
double *pInA1 = inA1;
double *pInA2 = inA2;
double *poutarr = pOutArr;
double *outEnd = poutarr + retSystemArr.Length;
while (poutarr < outEnd) //HC11
{
*poutarr++ = (*pInA1++ - (*pInA2++));
}
}
}
return(new ILArray <double> (retSystemArr, inDim));
#endregion array + array
}
}
}
/// <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>new ILLogicalArray with result of operation for corresponding
/// elements of both arrays.</returns>
/// <remarks>The values of inArray2 nor inArray2 will not be altered.The dimensions
/// of both arrays must match.</remarks>
private static ILArray <double> DoubleBinaryDoubleOperator(ILArray <double> inArray1, ILArray <double> inArray2,
ILApplyDouble_DoubleDouble operation)
{
ILDimension inDim = inArray1.Dimensions;
if (!inDim.IsSameSize(inArray2.Dimensions))
{
throw new Exception("Array dimensions must match.");
}
double[] retBoolArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retBoolArr = new double[newLength];
int leadDim = 0;
int leadDimLen = inDim[0];
if (inArray1.IsReference || inArray2.IsReference)
{
// this will most probably be not very fast, but .... :|
#region Reference storage
// 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;
}
}
ILIterator <double> it1 = inArray1.CreateIterator(ILIteratorPositions.ILEnd, leadDim);
ILIterator <double> it2 = inArray2.CreateIterator(ILIteratorPositions.ILEnd, leadDim);
unsafe
{
fixed(double *pOutArr = retBoolArr)
{
double *poutarr = pOutArr;
double *outEnd = poutarr + newLength;
while (poutarr < outEnd)
{
*poutarr++ = operation(it1.Increment(), it2.Increment());
}
}
}
// ==============================================================
#endregion
}
else
{
// physical -> pointer arithmetic
#region physical storage
unsafe
{
fixed(double *pInArr1 = inArray1.m_data,
pInArr2 = inArray2.m_data)
{
fixed(double *pOutArr = retBoolArr)
{
double *poutarr = pOutArr;
double *poutend = poutarr + newLength;
double *pIn1 = pInArr1;
double *pIn2 = pInArr2;
while (poutarr < poutend)
{
*poutarr++ = operation(*pIn1++, *pIn2++);
}
}
}
}
#endregion
}
return(new ILArray <double>(retBoolArr, inDim.ToIntArray()));
}
// DO NOT EDIT INSIDE THIS REGION !! CHANGES WILL BE LOST !!
/// <summary>Multiply elements</summary>
/// <param name="A">input 1</param>
/// <param name="B">input 2</param>
/// <returns>Array with elementwise multiplication of A and B</returns>
/// <remarks><para>On empty input - empty array will be returned.</para>
/// <para>A and / or B may be scalar. The scalar value will operate on all elements of the other arrays in this case.</para>
/// <para>If neither of A or B is scalar or empty, the dimensions of both arrays must match.</para></remarks>
public static ILArray <complex> multiplyElem(ILArray <complex> A, ILArray <complex> B)
{
if (A.IsEmpty)
{
return(ILArray <complex> .empty(A.Dimensions));
}
if (B.IsEmpty)
{
return(ILArray <complex> .empty(B.Dimensions));
}
if (A.IsScalar)
{
if (B.IsScalar)
{
return(new ILArray <complex> (new complex [1] {
(A.m_data[0] * B.m_data[0])
}));
}
else
{
#region scalar + array
ILDimension inDim = B.Dimensions;
complex [] retArr =
ILMemoryPool.Pool.New <complex> (inDim.NumberOfElements);
complex scalarValue = A.m_data[0];
unsafe
{
fixed(complex *pOutArr = retArr)
fixed(complex * pInArr = B.m_data)
{
complex *lastElement = pOutArr + retArr.Length;
complex *tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) //HC03
{
*tmpOut++ = (scalarValue * (*tmpIn++));
}
}
}
return(new ILArray <complex> (retArr, inDim));
#endregion scalar + array
}
}
else
{
if (B.IsScalar)
{
#region array + scalar
ILDimension inDim = A.Dimensions;
complex [] retArr =
ILMemoryPool.Pool.New <complex> (A.m_data.Length);
complex scalarValue = B.m_data[0];
unsafe
{
fixed(complex *pOutArr = retArr)
fixed(complex * pInArr = A.m_data)
{
complex *lastElement = pOutArr + retArr.Length;
complex *tmpOut = pOutArr;
complex *tmpIn = pInArr;
while (tmpOut < lastElement) //HC06
{
*tmpOut++ = (*tmpIn++ *scalarValue);
}
}
}
return(new ILArray <complex> (retArr, inDim));
#endregion array + scalar
}
else
{
#region array + array
ILDimension inDim = A.Dimensions;
if (!inDim.IsSameSize(B.Dimensions))
{
throw new ILDimensionMismatchException();
}
complex [] retSystemArr =
ILMemoryPool.Pool.New <complex> (inDim.NumberOfElements);
unsafe
{
fixed(complex *pOutArr = retSystemArr)
fixed(complex * inA1 = A.m_data)
fixed(complex * inA2 = B.m_data)
{
complex *pInA1 = inA1;
complex *pInA2 = inA2;
complex *poutarr = pOutArr;
complex *outEnd = poutarr + retSystemArr.Length;
while (poutarr < outEnd) //HC11
{
*poutarr++ = (*pInA1++ *(*pInA2++));
}
}
}
return(new ILArray <complex> (retSystemArr, inDim));
#endregion array + array
}
}
}
