00001 #ifndef Impala_Core_Array_Pattern_FuncMpo_h
00002 #define Impala_Core_Array_Pattern_FuncMpo_h
00003
00004 #include "Core/Array/Pattern/Categories.h"
00005 #include "Core/Array/Pattern/ArrayFunc.h"
00006
00007 namespace Impala
00008 {
00009 namespace Core
00010 {
00011 namespace Array
00012 {
00013 namespace Pattern
00014 {
00015
00016 template <class DstArrayT, class SrcArrayT, class MpoT>
00017 void
00018 FuncMpo(DstArrayT* dst, std::vector<SrcArrayT*> srcList, MpoT& mpo)
00019 {
00020 typedef typename DstArrayT::StorType DstStorT;
00021 typedef typename DstArrayT::ArithType DstArithT;
00022 typedef typename SrcArrayT::StorType SrcStorT;
00023 typedef typename SrcArrayT::ArithType SrcArithT;
00024
00025 int width = ArrayCW(dst);
00026 int height = ArrayCH(dst);
00027 int length = srcList.size();
00028 for (int y=0 ; y<height ; y++)
00029 {
00030 std::vector<SrcStorT*> srcPtrList;
00031 srcPtrList.resize(length);
00032 for(int i=0 ; i<length ; ++i)
00033 srcPtrList[i] = ArrayCPB(srcList[i], 0, y);
00034 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00035 for (int x=0 ; x<width ; x++)
00036 {
00037 std::vector<SrcStorT> valueList;
00038 valueList.resize(length);
00039 for(int i=0 ; i<length ; ++i)
00040 valueList[i] = PtrRead(srcPtrList[i], SrcArithT());
00041 PtrWrite(dPtr, mpo.DoIt(valueList));
00042 dPtr += DstArrayT::ElemSize();
00043 for(int i=0 ; i<length ; ++i)
00044 srcPtrList[i] += SrcArrayT::ElemSize();
00045 }
00046 }
00047 }
00048
00049
00050 template <class DstArrayT, class SrcArrayT, class MpoT>
00051 void
00052 FuncM3po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00053 MpoT& mpo)
00054 {
00055 typedef typename DstArrayT::StorType DstStorT;
00056 typedef typename DstArrayT::ArithType DstArithT;
00057 typedef typename SrcArrayT::StorType SrcStorT;
00058 typedef typename SrcArrayT::ArithType SrcArithT;
00059
00060 int width = ArrayCW(dst);
00061 int height = ArrayCH(dst);
00062 for (int y=0 ; y<height ; y++)
00063 {
00064 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00065 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00066 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00067 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00068 for (int x=0 ; x<width ; x++)
00069 {
00070 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00071 PtrRead(s2Ptr, SrcArithT()),
00072 PtrRead(s3Ptr, SrcArithT())));
00073 dPtr += DstArrayT::ElemSize();
00074 s1Ptr += SrcArrayT::ElemSize();
00075 s2Ptr += SrcArrayT::ElemSize();
00076 s3Ptr += SrcArrayT::ElemSize();
00077 }
00078 }
00079 }
00080
00081
00082 template <class DstArrayT, class SrcArrayT, class MpoT>
00083 void
00084 FuncM4po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3, SrcArrayT* src4,
00085 MpoT& mpo)
00086 {
00087 typedef typename DstArrayT::StorType DstStorT;
00088 typedef typename DstArrayT::ArithType DstArithT;
00089 typedef typename SrcArrayT::StorType SrcStorT;
00090 typedef typename SrcArrayT::ArithType SrcArithT;
00091
00092 int width = ArrayCW(dst);
00093 int height = ArrayCH(dst);
00094 for(int y=0 ; y<height ; y++)
00095 {
00096 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00097 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00098 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00099 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00100 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00101 for(int x=0 ; x<width ; x++)
00102 {
00103
00104 mpo.DoIt(dPtr, s1Ptr, s2Ptr, s3Ptr, s4Ptr);
00105 dPtr += DstArrayT::ElemSize();
00106 s1Ptr += SrcArrayT::ElemSize();
00107 s2Ptr += SrcArrayT::ElemSize();
00108 s3Ptr += SrcArrayT::ElemSize();
00109 s4Ptr += SrcArrayT::ElemSize();
00110 }
00111 }
00112 }
00113
00114
00115 template <class DstArrayT, class SrcArrayT, class MpoT>
00116 void
00117 FuncM6po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00118 SrcArrayT* src4, SrcArrayT* src5, SrcArrayT* src6, MpoT& mpo)
00119 {
00120 typedef typename DstArrayT::StorType DstStorT;
00121 typedef typename DstArrayT::ArithType DstArithT;
00122 typedef typename SrcArrayT::StorType SrcStorT;
00123 typedef typename SrcArrayT::ArithType SrcArithT;
00124
00125 int width = ArrayCW(dst);
00126 int height = ArrayCH(dst);
00127 for (int y=0 ; y<height ; y++)
00128 {
00129 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00130 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00131 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00132 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00133 SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
00134 SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
00135 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00136 for (int x=0 ; x<width ; x++)
00137 {
00138 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00139 PtrRead(s2Ptr, SrcArithT()),
00140 PtrRead(s3Ptr, SrcArithT()),
00141 PtrRead(s4Ptr, SrcArithT()),
00142 PtrRead(s5Ptr, SrcArithT()),
00143 PtrRead(s6Ptr, SrcArithT())));
00144 dPtr += DstArrayT::ElemSize();
00145 s1Ptr += SrcArrayT::ElemSize();
00146 s2Ptr += SrcArrayT::ElemSize();
00147 s3Ptr += SrcArrayT::ElemSize();
00148 s4Ptr += SrcArrayT::ElemSize();
00149 s5Ptr += SrcArrayT::ElemSize();
00150 s6Ptr += SrcArrayT::ElemSize();
00151 }
00152 }
00153 }
00154
00155 template <class DstArrayT, class SrcArrayT, class MpoT>
00156 void
00157 FuncM9po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00158 SrcArrayT* src4, SrcArrayT* src5, SrcArrayT* src6, SrcArrayT* src7,
00159 SrcArrayT* src8, SrcArrayT* src9, MpoT& mpo)
00160 {
00161 typedef typename DstArrayT::StorType DstStorT;
00162 typedef typename DstArrayT::ArithType DstArithT;
00163 typedef typename SrcArrayT::StorType SrcStorT;
00164 typedef typename SrcArrayT::ArithType SrcArithT;
00165
00166 int width = ArrayCW(dst);
00167 int height = ArrayCH(dst);
00168 for (int y=0 ; y<height ; y++)
00169 {
00170 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00171 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00172 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00173 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00174 SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
00175 SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
00176 SrcStorT* s7Ptr = ArrayCPB(src7 , 0, y);
00177 SrcStorT* s8Ptr = ArrayCPB(src8, 0, y);
00178 SrcStorT* s9Ptr = ArrayCPB(src9, 0, y);
00179 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00180 for (int x=0 ; x<width ; x++)
00181 {
00182 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00183 PtrRead(s2Ptr, SrcArithT()),
00184 PtrRead(s3Ptr, SrcArithT()),
00185 PtrRead(s4Ptr, SrcArithT()),
00186 PtrRead(s5Ptr, SrcArithT()),
00187 PtrRead(s6Ptr, SrcArithT()),
00188 PtrRead(s7Ptr, SrcArithT()),
00189 PtrRead(s8Ptr, SrcArithT()),
00190 PtrRead(s9Ptr, SrcArithT())));
00191 dPtr += DstArrayT::ElemSize();
00192 s1Ptr += SrcArrayT::ElemSize();
00193 s2Ptr += SrcArrayT::ElemSize();
00194 s3Ptr += SrcArrayT::ElemSize();
00195 s4Ptr += SrcArrayT::ElemSize();
00196 s5Ptr += SrcArrayT::ElemSize();
00197 s6Ptr += SrcArrayT::ElemSize();
00198 s7Ptr += SrcArrayT::ElemSize();
00199 s8Ptr += SrcArrayT::ElemSize();
00200 s9Ptr += SrcArrayT::ElemSize();
00201 }
00202 }
00203 }
00204
00205 template <class DstArrayT, class SrcArrayT, class MpoT>
00206 void
00207 FuncM12po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00208 SrcArrayT* src4, SrcArrayT* src5, SrcArrayT* src6, SrcArrayT* src7,
00209 SrcArrayT* src8, SrcArrayT* src9, SrcArrayT* src10, SrcArrayT* src11,
00210 SrcArrayT* src12, MpoT& mpo)
00211 {
00212 typedef typename DstArrayT::StorType DstStorT;
00213 typedef typename DstArrayT::ArithType DstArithT;
00214 typedef typename SrcArrayT::StorType SrcStorT;
00215 typedef typename SrcArrayT::ArithType SrcArithT;
00216
00217 int width = ArrayCW(dst);
00218 int height = ArrayCH(dst);
00219 for (int y=0 ; y<height ; y++)
00220 {
00221 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00222 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00223 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00224 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00225 SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
00226 SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
00227 SrcStorT* s7Ptr = ArrayCPB(src7, 0, y);
00228 SrcStorT* s8Ptr = ArrayCPB(src8, 0, y);
00229 SrcStorT* s9Ptr = ArrayCPB(src9, 0, y);
00230 SrcStorT* s10Ptr = ArrayCPB(src10, 0, y);
00231 SrcStorT* s11Ptr = ArrayCPB(src11, 0, y);
00232 SrcStorT* s12Ptr = ArrayCPB(src12, 0, y);
00233 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00234 for (int x=0 ; x<width ; x++)
00235 {
00236 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00237 PtrRead(s2Ptr, SrcArithT()),
00238 PtrRead(s3Ptr, SrcArithT()),
00239 PtrRead(s4Ptr, SrcArithT()),
00240 PtrRead(s5Ptr, SrcArithT()),
00241 PtrRead(s6Ptr, SrcArithT()),
00242 PtrRead(s7Ptr, SrcArithT()),
00243 PtrRead(s8Ptr, SrcArithT()),
00244 PtrRead(s9Ptr, SrcArithT()),
00245 PtrRead(s10Ptr, SrcArithT()),
00246 PtrRead(s11Ptr, SrcArithT()),
00247 PtrRead(s12Ptr, SrcArithT())));
00248 dPtr += DstArrayT::ElemSize();
00249 s1Ptr += SrcArrayT::ElemSize();
00250 s2Ptr += SrcArrayT::ElemSize();
00251 s3Ptr += SrcArrayT::ElemSize();
00252 s4Ptr += SrcArrayT::ElemSize();
00253 s5Ptr += SrcArrayT::ElemSize();
00254 s6Ptr += SrcArrayT::ElemSize();
00255 s7Ptr += SrcArrayT::ElemSize();
00256 s8Ptr += SrcArrayT::ElemSize();
00257 s9Ptr += SrcArrayT::ElemSize();
00258 s10Ptr += SrcArrayT::ElemSize();
00259 s11Ptr += SrcArrayT::ElemSize();
00260 s12Ptr += SrcArrayT::ElemSize();
00261 }
00262 }
00263 }
00264
00265 template <class DstArrayT, class SrcArrayT, class MpoT>
00266 void
00267 FuncM21po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00268 SrcArrayT* src4, SrcArrayT* src5, SrcArrayT* src6, SrcArrayT* src7,
00269 SrcArrayT* src8, SrcArrayT* src9, SrcArrayT* src10, SrcArrayT* src11,
00270 SrcArrayT* src12, SrcArrayT* src13, SrcArrayT* src14,
00271 SrcArrayT* src15, SrcArrayT* src16, SrcArrayT* src17,
00272 SrcArrayT* src18, SrcArrayT* src19, SrcArrayT* src20,
00273 SrcArrayT* src21, MpoT& mpo)
00274 {
00275 typedef typename DstArrayT::StorType DstStorT;
00276 typedef typename DstArrayT::ArithType DstArithT;
00277 typedef typename SrcArrayT::StorType SrcStorT;
00278 typedef typename SrcArrayT::ArithType SrcArithT;
00279
00280 int width = ArrayCW(dst);
00281 int height = ArrayCH(dst);
00282 for (int y=0 ; y<height ; y++)
00283 {
00284 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00285 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00286 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00287 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00288 SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
00289 SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
00290 SrcStorT* s7Ptr = ArrayCPB(src7, 0, y);
00291 SrcStorT* s8Ptr = ArrayCPB(src8, 0, y);
00292 SrcStorT* s9Ptr = ArrayCPB(src9, 0, y);
00293 SrcStorT* s10Ptr = ArrayCPB(src10, 0, y);
00294 SrcStorT* s11Ptr = ArrayCPB(src11, 0, y);
00295 SrcStorT* s12Ptr = ArrayCPB(src12, 0, y);
00296 SrcStorT* s13Ptr = ArrayCPB(src13, 0, y);
00297 SrcStorT* s14Ptr = ArrayCPB(src14, 0, y);
00298 SrcStorT* s15Ptr = ArrayCPB(src15, 0, y);
00299 SrcStorT* s16Ptr = ArrayCPB(src16, 0, y);
00300 SrcStorT* s17Ptr = ArrayCPB(src17, 0, y);
00301 SrcStorT* s18Ptr = ArrayCPB(src18, 0, y);
00302 SrcStorT* s19Ptr = ArrayCPB(src19, 0, y);
00303 SrcStorT* s20Ptr = ArrayCPB(src20, 0, y);
00304 SrcStorT* s21Ptr = ArrayCPB(src21, 0, y);
00305 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00306 for (int x=0 ; x<width ; x++)
00307 {
00308 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00309 PtrRead(s2Ptr, SrcArithT()),
00310 PtrRead(s3Ptr, SrcArithT()),
00311 PtrRead(s4Ptr, SrcArithT()),
00312 PtrRead(s5Ptr, SrcArithT()),
00313 PtrRead(s6Ptr, SrcArithT()),
00314 PtrRead(s7Ptr, SrcArithT()),
00315 PtrRead(s8Ptr, SrcArithT()),
00316 PtrRead(s9Ptr, SrcArithT()),
00317 PtrRead(s10Ptr, SrcArithT()),
00318 PtrRead(s11Ptr, SrcArithT()),
00319 PtrRead(s12Ptr, SrcArithT()),
00320 PtrRead(s13Ptr, SrcArithT()),
00321 PtrRead(s14Ptr, SrcArithT()),
00322 PtrRead(s15Ptr, SrcArithT()),
00323 PtrRead(s16Ptr, SrcArithT()),
00324 PtrRead(s17Ptr, SrcArithT()),
00325 PtrRead(s18Ptr, SrcArithT()),
00326 PtrRead(s19Ptr, SrcArithT()),
00327 PtrRead(s20Ptr, SrcArithT()),
00328 PtrRead(s21Ptr, SrcArithT())));
00329 dPtr += DstArrayT::ElemSize();
00330 s1Ptr += SrcArrayT::ElemSize();
00331 s2Ptr += SrcArrayT::ElemSize();
00332 s3Ptr += SrcArrayT::ElemSize();
00333 s4Ptr += SrcArrayT::ElemSize();
00334 s5Ptr += SrcArrayT::ElemSize();
00335 s6Ptr += SrcArrayT::ElemSize();
00336 s7Ptr += SrcArrayT::ElemSize();
00337 s8Ptr += SrcArrayT::ElemSize();
00338 s9Ptr += SrcArrayT::ElemSize();
00339 s10Ptr += SrcArrayT::ElemSize();
00340 s11Ptr += SrcArrayT::ElemSize();
00341 s12Ptr += SrcArrayT::ElemSize();
00342 s13Ptr += SrcArrayT::ElemSize();
00343 s14Ptr += SrcArrayT::ElemSize();
00344 s15Ptr += SrcArrayT::ElemSize();
00345 s16Ptr += SrcArrayT::ElemSize();
00346 s17Ptr += SrcArrayT::ElemSize();
00347 s18Ptr += SrcArrayT::ElemSize();
00348 s19Ptr += SrcArrayT::ElemSize();
00349 s20Ptr += SrcArrayT::ElemSize();
00350 s21Ptr += SrcArrayT::ElemSize();
00351 }
00352 }
00353 }
00354
00355 template <class DstArrayT, class SrcArrayT, class MpoT>
00356 void
00357 FuncM22po(DstArrayT* dst, SrcArrayT* src1, SrcArrayT* src2, SrcArrayT* src3,
00358 SrcArrayT* src4, SrcArrayT* src5, SrcArrayT* src6, SrcArrayT* src7,
00359 SrcArrayT* src8, SrcArrayT* src9, SrcArrayT* src10, SrcArrayT* src11,
00360 SrcArrayT* src12, SrcArrayT* src13, SrcArrayT* src14,
00361 SrcArrayT* src15, SrcArrayT* src16, SrcArrayT* src17,
00362 SrcArrayT* src18, SrcArrayT* src19, SrcArrayT* src20,
00363 SrcArrayT* src21, SrcArrayT* src22, MpoT& mpo)
00364 {
00365 typedef typename DstArrayT::StorType DstStorT;
00366 typedef typename DstArrayT::ArithType DstArithT;
00367 typedef typename SrcArrayT::StorType SrcStorT;
00368 typedef typename SrcArrayT::ArithType SrcArithT;
00369
00370 int width = ArrayCW(dst);
00371 int height = ArrayCH(dst);
00372 for (int y=0 ; y<height ; y++)
00373 {
00374 SrcStorT* s1Ptr = ArrayCPB(src1, 0, y);
00375 SrcStorT* s2Ptr = ArrayCPB(src2, 0, y);
00376 SrcStorT* s3Ptr = ArrayCPB(src3, 0, y);
00377 SrcStorT* s4Ptr = ArrayCPB(src4, 0, y);
00378 SrcStorT* s5Ptr = ArrayCPB(src5, 0, y);
00379 SrcStorT* s6Ptr = ArrayCPB(src6, 0, y);
00380 SrcStorT* s7Ptr = ArrayCPB(src7, 0, y);
00381 SrcStorT* s8Ptr = ArrayCPB(src8, 0, y);
00382 SrcStorT* s9Ptr = ArrayCPB(src9, 0, y);
00383 SrcStorT* s10Ptr = ArrayCPB(src10, 0, y);
00384 SrcStorT* s11Ptr = ArrayCPB(src11, 0, y);
00385 SrcStorT* s12Ptr = ArrayCPB(src12, 0, y);
00386 SrcStorT* s13Ptr = ArrayCPB(src13, 0, y);
00387 SrcStorT* s14Ptr = ArrayCPB(src14, 0, y);
00388 SrcStorT* s15Ptr = ArrayCPB(src15, 0, y);
00389 SrcStorT* s16Ptr = ArrayCPB(src16, 0, y);
00390 SrcStorT* s17Ptr = ArrayCPB(src17, 0, y);
00391 SrcStorT* s18Ptr = ArrayCPB(src18, 0, y);
00392 SrcStorT* s19Ptr = ArrayCPB(src19, 0, y);
00393 SrcStorT* s20Ptr = ArrayCPB(src20, 0, y);
00394 SrcStorT* s21Ptr = ArrayCPB(src21, 0, y);
00395 SrcStorT* s22Ptr = ArrayCPB(src22, 0, y);
00396 DstStorT* dPtr = ArrayCPB(dst, 0, y);
00397 for (int x=0 ; x<width ; x++)
00398 {
00399 PtrWrite(dPtr, mpo.DoIt(PtrRead(s1Ptr, SrcArithT()),
00400 PtrRead(s2Ptr, SrcArithT()),
00401 PtrRead(s3Ptr, SrcArithT()),
00402 PtrRead(s4Ptr, SrcArithT()),
00403 PtrRead(s5Ptr, SrcArithT()),
00404 PtrRead(s6Ptr, SrcArithT()),
00405 PtrRead(s7Ptr, SrcArithT()),
00406 PtrRead(s8Ptr, SrcArithT()),
00407 PtrRead(s9Ptr, SrcArithT()),
00408 PtrRead(s10Ptr, SrcArithT()),
00409 PtrRead(s11Ptr, SrcArithT()),
00410 PtrRead(s12Ptr, SrcArithT()),
00411 PtrRead(s13Ptr, SrcArithT()),
00412 PtrRead(s14Ptr, SrcArithT()),
00413 PtrRead(s15Ptr, SrcArithT()),
00414 PtrRead(s16Ptr, SrcArithT()),
00415 PtrRead(s17Ptr, SrcArithT()),
00416 PtrRead(s18Ptr, SrcArithT()),
00417 PtrRead(s19Ptr, SrcArithT()),
00418 PtrRead(s20Ptr, SrcArithT()),
00419 PtrRead(s21Ptr, SrcArithT()),
00420 PtrRead(s22Ptr, SrcArithT())));
00421 dPtr += DstArrayT::ElemSize();
00422 s1Ptr += SrcArrayT::ElemSize();
00423 s2Ptr += SrcArrayT::ElemSize();
00424 s3Ptr += SrcArrayT::ElemSize();
00425 s4Ptr += SrcArrayT::ElemSize();
00426 s5Ptr += SrcArrayT::ElemSize();
00427 s6Ptr += SrcArrayT::ElemSize();
00428 s7Ptr += SrcArrayT::ElemSize();
00429 s8Ptr += SrcArrayT::ElemSize();
00430 s9Ptr += SrcArrayT::ElemSize();
00431 s10Ptr += SrcArrayT::ElemSize();
00432 s11Ptr += SrcArrayT::ElemSize();
00433 s12Ptr += SrcArrayT::ElemSize();
00434 s13Ptr += SrcArrayT::ElemSize();
00435 s14Ptr += SrcArrayT::ElemSize();
00436 s15Ptr += SrcArrayT::ElemSize();
00437 s16Ptr += SrcArrayT::ElemSize();
00438 s17Ptr += SrcArrayT::ElemSize();
00439 s18Ptr += SrcArrayT::ElemSize();
00440 s19Ptr += SrcArrayT::ElemSize();
00441 s20Ptr += SrcArrayT::ElemSize();
00442 s21Ptr += SrcArrayT::ElemSize();
00443 s22Ptr += SrcArrayT::ElemSize();
00444 }
00445 }
00446 }
00447
00448 }
00449 }
00450 }
00451 }
00452
00453 #endif
