internal opfcomplex_fcomplex ( fcomplex parameter,
ILFcomplexFunctionFcomplexFcomplex applyFunc) {
m_parameter = parameter;
m_applyFun = applyFunc;
}
/// <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<fcomplex> ]]> 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<fcomplex> FcomplexOperatorFcomplexFcomplex ( ILArray<fcomplex> inArray1, ILArray<fcomplex> inArray2,
ILFcomplexFunctionFcomplexFcomplex operation) {
ILDimension inDim = inArray1.Dimensions;
if (!inDim.IsSameSize ( inArray2.Dimensions ))
throw new ILDimensionMismatchException ();
fcomplex [] retSystemArr;
// build ILDimension
int newLength = inDim.NumberOfElements;
retSystemArr = new fcomplex [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;
}
}
unsafe {
fixed ( fcomplex * pOutArr = retSystemArr)
fixed ( fcomplex * inA1 = inArray1.m_data)
fixed ( fcomplex * inA2 = inArray2.m_data) {
fcomplex * pInA1 = inA1;
fcomplex * pInA2 = inA2;
int c = 0;
fcomplex * poutarr = pOutArr;
fcomplex * outEnd = poutarr + newLength;
if (inArray1.IsReference && !inArray2.IsReference)
while (poutarr < outEnd) {
*poutarr++ = operation ( *(pInA1 + inArray1.getBaseIndex(c++)), *pInA2++);
}
else if (!inArray1.IsReference && inArray2.IsReference)
while (poutarr < outEnd) {
*poutarr++ = operation ( *pInA1++, *(pInA2 + inArray2.getBaseIndex(c++)));
}
else if (!inArray1.IsReference && !inArray2.IsReference)
while (poutarr < outEnd) {
*poutarr++ = operation ( *pInA1++, *pInA2++);
}
else if (inArray1.IsReference && inArray2.IsReference)
if (inArray1.Dimensions.NumberOfDimensions < 3 && inArray2.Dimensions.NumberOfDimensions < 3) {
fixed (int * pA1idx0 = inArray1.m_indexOffset[0])
fixed (int * pA1idx1 = inArray1.m_indexOffset[1])
fixed (int * pA2idx0 = inArray2.m_indexOffset[0])
fixed (int * pA2idx1 = inArray2.m_indexOffset[1]) {
int r = 0, rLen = inArray1.m_dimensions[0];
int cLen = inArray1.m_dimensions[1];
while (poutarr < outEnd) {
*poutarr++ = operation ( *(pInA1 + *(pA1idx0 + r) + *(pA1idx1 + c)), *(pInA2+ *(pA2idx0 + r) + *(pA2idx1 + c)));
if (++r == rLen) {
r = 0;
c++;
}
}
}
} else {
while (poutarr < outEnd) {
*poutarr++ = operation ( *(pInA1 + inArray1.getBaseIndex(c)), *(pInA2+inArray2.getBaseIndex(c++)));
}
}
}
}
// ==============================================================
#endregion
} else {
// physical -> pointer arithmetic
#region physical storage
unsafe {
fixed ( fcomplex * pInArr1 = inArray1.m_data)
fixed ( fcomplex * pInArr2 = inArray2.m_data)
fixed ( fcomplex * pOutArr = retSystemArr) {
fcomplex * poutarr = pOutArr;
fcomplex * poutend = poutarr + newLength;
fcomplex * pIn1 = pInArr1;
fcomplex * pIn2 = pInArr2;
while (poutarr < poutend)
*poutarr++ = operation ( *pIn1++, *pIn2++ );
}
}
#endregion
}
return new ILArray<fcomplex> ( retSystemArr, inDim.ToIntArray () );
}
