internal /*!HC:Tcls3Name*/ opdouble_double (/*!HC:inArr2*/ double parameter, /*!HC:delegate_binary*/ ILDoubleFunctionDoubleDouble applyFunc) { m_parameter = parameter; m_applyFun = applyFunc; }
internal /*!HC:Tcls3Name*/ opdouble_double(/*!HC:inArr2*/ double parameter, /*!HC:delegate_binary*/ ILDoubleFunctionDoubleDouble applyFunc) { m_parameter = parameter; m_applyFun = applyFunc; }
/*!HC:TYPELIST: <hycalper> <type> <source locate="after"> inArr1 </source> <destination>byte</destination> <destination>char</destination> <destination>complex</destination> <destination>fcomplex</destination> <destination>float</destination> <destination>Int16</destination> <destination>Int32</destination> <destination>Int64</destination> <destination>UInt16</destination> <destination>UInt32</destination> <destination>UInt64</destination> </type> <type> <source locate="after"> inArr2 </source> <destination>byte</destination> <destination>char</destination> <destination>complex</destination> <destination>fcomplex</destination> <destination>float</destination> <destination>Int16</destination> <destination>Int32</destination> <destination>Int64</destination> <destination>UInt16</destination> <destination>UInt32</destination> <destination>UInt64</destination> </type> <type> <source locate="after"> inCls1 </source> <destination><![CDATA[ILArray<byte>]]></destination> <destination><![CDATA[ILArray<char>]]></destination> <destination><![CDATA[ILArray<complex>]]></destination> <destination><![CDATA[ILArray<fcomplex>]]></destination> <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> </type> <type> <source locate="after"> inCls2 </source> <destination><![CDATA[ILArray<byte>]]></destination> <destination><![CDATA[ILArray<char>]]></destination> <destination><![CDATA[ILArray<complex>]]></destination> <destination><![CDATA[ILArray<fcomplex>]]></destination> <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> </type> <type> <source locate="after"> outCls1 </source> <destination><![CDATA[ILArray<byte>]]></destination> <destination><![CDATA[ILArray<char>]]></destination> <destination><![CDATA[ILArray<complex>]]></destination> <destination><![CDATA[ILArray<fcomplex>]]></destination> <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> </type> <type> <source locate="after"> outArr1 </source> <destination>byte</destination> <destination>char</destination> <destination>complex</destination> <destination>fcomplex</destination> <destination>float</destination> <destination>Int16</destination> <destination>Int32</destination> <destination>Int64</destination> <destination>UInt16</destination> <destination>UInt32</destination> <destination>UInt64</destination> </type> <type> <source locate="after"> delegate_binary </source> <destination>ILByteFunctionByteByte</destination> <destination>ILCharFunctionCharChar</destination> <destination>ILComplexFunctionComplexComplex</destination> <destination>ILFcomplexFunctionFcomplexFcomplex</destination> <destination>ILFloatFunctionFloatFloat</destination> <destination>ILInt16FunctionInt16Int16</destination> <destination>ILInt32FunctionInt32Int32</destination> <destination>ILInt64FunctionInt64Int64</destination> <destination>ILUInt16FunctionUInt16UInt16</destination> <destination>ILUInt32FunctionUInt32UInt32</destination> <destination>ILUInt64FunctionUInt64UInt64</destination> </type> <type> <source locate="after"> hcfunctionName </source> <destination>ByteOperatorByteByte</destination> <destination>CharOperatorCharChar</destination> <destination>ComplexOperatorComplexComplex</destination> <destination>FcomplexOperatorFcomplexFcomplex</destination> <destination>FloatOperatorFloatFloat</destination> <destination>Int16OperatorInt16Int16</destination> <destination>Int32OperatorInt32Int32</destination> <destination>Int64OperatorInt64Int64</destination> <destination>UInt16OperatorUInt16UInt16</destination> <destination>UInt32OperatorUInt32UInt32</destination> <destination>UInt64OperatorUInt64UInt64</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 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 (/*!HC:outArr1*/ double * pOutArr = retSystemArr) fixed (/*!HC:inArr1*/ double * inA1 = inArray1.m_data) fixed (/*!HC:inArr2*/ double * inA2 = inArray2.m_data) { /*!HC:inArr1*/ double * pInA1 = inA1; /*!HC:inArr2*/ double * pInA2 = inA2; int c = 0; /*!HC:outArr1*/ double * poutarr = pOutArr; /*!HC:outArr1*/ double * 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 (/*!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++ ); } } #endregion } return new /*!HC:outCls1*/ ILArray<double> ( 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())); }
/*!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 () ); }