internal opint64_int64 ( Int64 parameter, ILInt64FunctionInt64Int64 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<Int64> ]]> 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<Int64> Int64OperatorInt64Int64 ( ILArray<Int64> inArray1, ILArray<Int64> inArray2, ILInt64FunctionInt64Int64 operation) { ILDimension inDim = inArray1.Dimensions; if (!inDim.IsSameSize ( inArray2.Dimensions )) throw new ILDimensionMismatchException (); Int64 [] retSystemArr; // build ILDimension int newLength = inDim.NumberOfElements; retSystemArr = new Int64 [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 ( Int64 * pOutArr = retSystemArr) fixed ( Int64 * inA1 = inArray1.m_data) fixed ( Int64 * inA2 = inArray2.m_data) { Int64 * pInA1 = inA1; Int64 * pInA2 = inA2; int c = 0; Int64 * poutarr = pOutArr; Int64 * 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 ( Int64 * pInArr1 = inArray1.m_data) fixed ( Int64 * pInArr2 = inArray2.m_data) fixed ( Int64 * pOutArr = retSystemArr) { Int64 * poutarr = pOutArr; Int64 * poutend = poutarr + newLength; Int64 * pIn1 = pInArr1; Int64 * pIn2 = pInArr2; while (poutarr < poutend) *poutarr++ = operation ( *pIn1++, *pIn2++ ); } } #endregion } return new ILArray<Int64> ( retSystemArr, inDim.ToIntArray () ); }