Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2.1 of the GNU Lesser General Public License 00007 as published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU Lesser General Public 00021 License along with this program; if not, write the Free Software 00022 Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 00023 USA. 00024 00025 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00026 Mountain View, CA 94043, or: 00027 00028 http://www.sgi.com 00029 00030 For further information regarding this notice, see: 00031 00032 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00033 00034 */ 00035 00036 /* automatically generated file, do not edit */ 00037 00038 #include "f90_intrinsic.h" 00039 00040 static size_t read_source_desc(DopeVectorType * array, 00041 size_t src_extent[MAX_NARY_DIMS], 00042 size_t src_stride[MAX_NARY_DIMS], 00043 size_t src_offset[MAX_NARY_DIMS], 00044 int32_t ddim) ; 00045 00046 static void 00047 get_offset_and_stride(DopeVectorType * array, 00048 size_t src_extent[MAX_NARY_DIMS], 00049 size_t src_stride[MAX_NARY_DIMS], 00050 size_t src_offset[MAX_NARY_DIMS], 00051 int32_t ddim) ; 00052 00053 static int32_t read_dim(DopeVectorType * dim) ; 00054 00055 static void alloc_res(DopeVectorType * result, 00056 size_t src_extent[MAX_NARY_DIMS]); 00057 00058 void 00059 _MAXVAL__I1( 00060 DopeVectorType *result, 00061 DopeVectorType *array, 00062 DopeVectorType *dim, 00063 DopeVectorType *mask) 00064 { 00065 char * result_p, * result_b ; 00066 char * array_p, * array_b ; 00067 char * dim_p, * dim_b ; 00068 char * mask_p, * mask_b ; 00069 00070 size_t src_extent [MAX_NARY_DIMS] ; 00071 size_t counter [MAX_NARY_DIMS] ; 00072 size_t src_offset [MAX_NARY_DIMS] ; 00073 size_t src_stride [MAX_NARY_DIMS] ; 00074 size_t src_size ; 00075 00076 size_t res_stride [MAX_NARY_DIMS] ; 00077 size_t res_offset [MAX_NARY_DIMS] ; 00078 00079 size_t msk_stride [MAX_NARY_DIMS] ; 00080 size_t msk_offset [MAX_NARY_DIMS] ; 00081 00082 int32_t ddim ; 00083 uint32_t src_rank ; 00084 uint32_t res_rank ; 00085 00086 size_t j,k,i ; 00087 size_t msk_typ_sz; 00088 00089 i1 accum ; 00090 i1 const initv = INT8_MIN ; 00091 size_t a_size,a_stride; 00092 size_t m_stride ; 00093 00094 i1 temp,new ; 00095 00096 if (mask == NULL) { /* is third arg mask or dim? */ 00097 if (dim != NULL) { 00098 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00099 mask = (DopeVectorType *) dim ; 00100 dim = NULL; 00101 } 00102 } 00103 } 00104 00105 if (dim != NULL) { 00106 ddim = read_dim(dim); 00107 } else 00108 ddim = 0 ; 00109 00110 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00111 src_rank = GET_RANK_FROM_DESC(array) - 1; 00112 00113 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00114 00115 for (i = 0 ; i <= src_rank ; i ++) 00116 counter[i] = 0 ; 00117 00118 if ((ddim > src_rank ) || (ddim < 0)) 00119 ERROR(_LELVL_ABORT,FESCIDIM); 00120 00121 res_rank = GET_RANK_FROM_DESC(result); 00122 00123 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00124 alloc_res(result,src_extent); 00125 } 00126 00127 res_stride[0] = 0; 00128 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00129 for (j = 0 ; j < res_rank ; j ++ ) { 00130 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00131 } 00132 00133 res_offset[0] = res_stride[0] ; 00134 for ( j = 1 ; j < res_rank ; j ++ ) 00135 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00136 00137 result_b = GET_ADDRESS_FROM_DESC(result); 00138 00139 if (mask != NULL) { 00140 00141 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00142 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00143 00144 if (GET_RANK_FROM_DESC(mask) == 0) { 00145 if (*mask_b) { 00146 mask = NULL; 00147 } else { 00148 src_size = 0; 00149 for (j = 0 ; j <= src_rank ; j ++) { 00150 msk_stride[j] = 0 ; 00151 msk_offset[j] = 0 ; 00152 } 00153 } 00154 00155 } else { 00156 00157 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00158 } 00159 } 00160 00161 accum = initv ; 00162 00163 if (src_size == 0 ) { 00164 for (i = 1 ; i <= src_rank ; i ++ ) 00165 if (src_extent[i] == 0) 00166 return ; 00167 } 00168 array_p = array_b ; 00169 result_p = result_b ; 00170 if (mask == NULL) { 00171 00172 a_size = src_extent[0] ; 00173 a_stride = src_stride[0] ; 00174 00175 while (counter[src_rank] < src_extent[src_rank] ) { 00176 00177 if(res_rank != 0) accum = initv ; 00178 00179 for ( i = 0 ; i < a_size ; i ++ ) { 00180 if (*(i1 *)array_p > accum ) { 00181 accum = * (i1 *)array_p ; 00182 } 00183 array_p += a_stride ; 00184 } 00185 *(i1 *) result_p = accum ; 00186 counter[0] = a_size ; 00187 j = 0 ; 00188 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00189 array_p += src_offset[j] ; 00190 result_p += res_offset[j] ; 00191 counter[j+1]++ ; 00192 counter[j] = 0 ; 00193 j ++ ; 00194 } 00195 } 00196 } else { 00197 00198 a_size = src_extent[0] ; 00199 a_stride = src_stride[0] ; 00200 m_stride = msk_stride[0] ; 00201 mask_p = mask_b ; 00202 00203 while (counter[src_rank] < src_extent[src_rank] ) { 00204 00205 if(res_rank != 0) accum = initv ; 00206 00207 for ( i = 0 ; i < a_size ; i ++ ) { 00208 if (*mask_p) { 00209 if (*(i1 *)array_p > accum ) { 00210 accum = * (i1 *)array_p ; 00211 } 00212 } 00213 array_p += a_stride ; 00214 mask_p += m_stride ; 00215 } 00216 *(i1 *) result_p = accum ; 00217 counter[0] = a_size ; 00218 j = 0 ; 00219 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00220 array_p += src_offset[j] ; 00221 mask_p += msk_offset[j] ; 00222 result_p += res_offset[j] ; 00223 counter[j+1]++ ; 00224 counter[j] = 0 ; 00225 j ++ ; 00226 } 00227 } 00228 } 00229 } 00230 void 00231 _MAXVAL__I2( 00232 DopeVectorType *result, 00233 DopeVectorType *array, 00234 DopeVectorType *dim, 00235 DopeVectorType *mask) 00236 { 00237 char * result_p, * result_b ; 00238 char * array_p, * array_b ; 00239 char * dim_p, * dim_b ; 00240 char * mask_p, * mask_b ; 00241 00242 size_t src_extent [MAX_NARY_DIMS] ; 00243 size_t counter [MAX_NARY_DIMS] ; 00244 size_t src_offset [MAX_NARY_DIMS] ; 00245 size_t src_stride [MAX_NARY_DIMS] ; 00246 size_t src_size ; 00247 00248 size_t res_stride [MAX_NARY_DIMS] ; 00249 size_t res_offset [MAX_NARY_DIMS] ; 00250 00251 size_t msk_stride [MAX_NARY_DIMS] ; 00252 size_t msk_offset [MAX_NARY_DIMS] ; 00253 00254 int32_t ddim ; 00255 uint32_t src_rank ; 00256 uint32_t res_rank ; 00257 00258 size_t j,k,i ; 00259 size_t msk_typ_sz; 00260 00261 i2 accum ; 00262 i2 const initv = INT16_MIN ; 00263 size_t a_size,a_stride; 00264 size_t m_stride ; 00265 00266 i2 temp,new ; 00267 00268 if (mask == NULL) { /* is third arg mask or dim? */ 00269 if (dim != NULL) { 00270 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00271 mask = (DopeVectorType *) dim ; 00272 dim = NULL; 00273 } 00274 } 00275 } 00276 00277 if (dim != NULL) { 00278 ddim = read_dim(dim); 00279 } else 00280 ddim = 0 ; 00281 00282 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00283 src_rank = GET_RANK_FROM_DESC(array) - 1; 00284 00285 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00286 00287 for (i = 0 ; i <= src_rank ; i ++) 00288 counter[i] = 0 ; 00289 00290 if ((ddim > src_rank ) || (ddim < 0)) 00291 ERROR(_LELVL_ABORT,FESCIDIM); 00292 00293 res_rank = GET_RANK_FROM_DESC(result); 00294 00295 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00296 alloc_res(result,src_extent); 00297 } 00298 00299 res_stride[0] = 0; 00300 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00301 for (j = 0 ; j < res_rank ; j ++ ) { 00302 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00303 } 00304 00305 res_offset[0] = res_stride[0] ; 00306 for ( j = 1 ; j < res_rank ; j ++ ) 00307 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00308 00309 result_b = GET_ADDRESS_FROM_DESC(result); 00310 00311 if (mask != NULL) { 00312 00313 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00314 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00315 00316 if (GET_RANK_FROM_DESC(mask) == 0) { 00317 if (*mask_b) { 00318 mask = NULL; 00319 } else { 00320 src_size = 0; 00321 for (j = 0 ; j <= src_rank ; j ++) { 00322 msk_stride[j] = 0 ; 00323 msk_offset[j] = 0 ; 00324 } 00325 } 00326 00327 } else { 00328 00329 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00330 } 00331 } 00332 00333 accum = initv ; 00334 00335 if (src_size == 0 ) { 00336 for (i = 1 ; i <= src_rank ; i ++ ) 00337 if (src_extent[i] == 0) 00338 return ; 00339 } 00340 array_p = array_b ; 00341 result_p = result_b ; 00342 if (mask == NULL) { 00343 00344 a_size = src_extent[0] ; 00345 a_stride = src_stride[0] ; 00346 00347 while (counter[src_rank] < src_extent[src_rank] ) { 00348 00349 if(res_rank != 0) accum = initv ; 00350 00351 for ( i = 0 ; i < a_size ; i ++ ) { 00352 if (*(i2 *)array_p > accum ) { 00353 accum = * (i2 *)array_p ; 00354 } 00355 array_p += a_stride ; 00356 } 00357 *(i2 *) result_p = accum ; 00358 counter[0] = a_size ; 00359 j = 0 ; 00360 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00361 array_p += src_offset[j] ; 00362 result_p += res_offset[j] ; 00363 counter[j+1]++ ; 00364 counter[j] = 0 ; 00365 j ++ ; 00366 } 00367 } 00368 } else { 00369 00370 a_size = src_extent[0] ; 00371 a_stride = src_stride[0] ; 00372 m_stride = msk_stride[0] ; 00373 mask_p = mask_b ; 00374 00375 while (counter[src_rank] < src_extent[src_rank] ) { 00376 00377 if(res_rank != 0) accum = initv ; 00378 00379 for ( i = 0 ; i < a_size ; i ++ ) { 00380 if (*mask_p) { 00381 if (*(i2 *)array_p > accum ) { 00382 accum = * (i2 *)array_p ; 00383 } 00384 } 00385 array_p += a_stride ; 00386 mask_p += m_stride ; 00387 } 00388 *(i2 *) result_p = accum ; 00389 counter[0] = a_size ; 00390 j = 0 ; 00391 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00392 array_p += src_offset[j] ; 00393 mask_p += msk_offset[j] ; 00394 result_p += res_offset[j] ; 00395 counter[j+1]++ ; 00396 counter[j] = 0 ; 00397 j ++ ; 00398 } 00399 } 00400 } 00401 } 00402 void 00403 _MAXVAL__I4( 00404 DopeVectorType *result, 00405 DopeVectorType *array, 00406 DopeVectorType *dim, 00407 DopeVectorType *mask) 00408 { 00409 char * result_p, * result_b ; 00410 char * array_p, * array_b ; 00411 char * dim_p, * dim_b ; 00412 char * mask_p, * mask_b ; 00413 00414 size_t src_extent [MAX_NARY_DIMS] ; 00415 size_t counter [MAX_NARY_DIMS] ; 00416 size_t src_offset [MAX_NARY_DIMS] ; 00417 size_t src_stride [MAX_NARY_DIMS] ; 00418 size_t src_size ; 00419 00420 size_t res_stride [MAX_NARY_DIMS] ; 00421 size_t res_offset [MAX_NARY_DIMS] ; 00422 00423 size_t msk_stride [MAX_NARY_DIMS] ; 00424 size_t msk_offset [MAX_NARY_DIMS] ; 00425 00426 int32_t ddim ; 00427 uint32_t src_rank ; 00428 uint32_t res_rank ; 00429 00430 size_t j,k,i ; 00431 size_t msk_typ_sz; 00432 00433 i4 accum ; 00434 i4 const initv = INT32_MIN ; 00435 size_t a_size,a_stride; 00436 size_t m_stride ; 00437 00438 i4 temp,new ; 00439 00440 if (mask == NULL) { /* is third arg mask or dim? */ 00441 if (dim != NULL) { 00442 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00443 mask = (DopeVectorType *) dim ; 00444 dim = NULL; 00445 } 00446 } 00447 } 00448 00449 if (dim != NULL) { 00450 ddim = read_dim(dim); 00451 } else 00452 ddim = 0 ; 00453 00454 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00455 src_rank = GET_RANK_FROM_DESC(array) - 1; 00456 00457 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00458 00459 for (i = 0 ; i <= src_rank ; i ++) 00460 counter[i] = 0 ; 00461 00462 if ((ddim > src_rank ) || (ddim < 0)) 00463 ERROR(_LELVL_ABORT,FESCIDIM); 00464 00465 res_rank = GET_RANK_FROM_DESC(result); 00466 00467 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00468 alloc_res(result,src_extent); 00469 } 00470 00471 res_stride[0] = 0; 00472 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00473 for (j = 0 ; j < res_rank ; j ++ ) { 00474 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00475 } 00476 00477 res_offset[0] = res_stride[0] ; 00478 for ( j = 1 ; j < res_rank ; j ++ ) 00479 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00480 00481 result_b = GET_ADDRESS_FROM_DESC(result); 00482 00483 if (mask != NULL) { 00484 00485 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00486 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00487 00488 if (GET_RANK_FROM_DESC(mask) == 0) { 00489 if (*mask_b) { 00490 mask = NULL; 00491 } else { 00492 src_size = 0; 00493 for (j = 0 ; j <= src_rank ; j ++) { 00494 msk_stride[j] = 0 ; 00495 msk_offset[j] = 0 ; 00496 } 00497 } 00498 00499 } else { 00500 00501 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00502 } 00503 } 00504 00505 accum = initv ; 00506 00507 if (src_size == 0 ) { 00508 for (i = 1 ; i <= src_rank ; i ++ ) 00509 if (src_extent[i] == 0) 00510 return ; 00511 } 00512 array_p = array_b ; 00513 result_p = result_b ; 00514 if (mask == NULL) { 00515 00516 a_size = src_extent[0] ; 00517 a_stride = src_stride[0] ; 00518 00519 while (counter[src_rank] < src_extent[src_rank] ) { 00520 00521 if(res_rank != 0) accum = initv ; 00522 00523 for ( i = 0 ; i < a_size ; i ++ ) { 00524 if (*(i4 *)array_p > accum ) { 00525 accum = * (i4 *)array_p ; 00526 } 00527 array_p += a_stride ; 00528 } 00529 *(i4 *) result_p = accum ; 00530 counter[0] = a_size ; 00531 j = 0 ; 00532 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00533 array_p += src_offset[j] ; 00534 result_p += res_offset[j] ; 00535 counter[j+1]++ ; 00536 counter[j] = 0 ; 00537 j ++ ; 00538 } 00539 } 00540 } else { 00541 00542 a_size = src_extent[0] ; 00543 a_stride = src_stride[0] ; 00544 m_stride = msk_stride[0] ; 00545 mask_p = mask_b ; 00546 00547 while (counter[src_rank] < src_extent[src_rank] ) { 00548 00549 if(res_rank != 0) accum = initv ; 00550 00551 for ( i = 0 ; i < a_size ; i ++ ) { 00552 if (*mask_p) { 00553 if (*(i4 *)array_p > accum ) { 00554 accum = * (i4 *)array_p ; 00555 } 00556 } 00557 array_p += a_stride ; 00558 mask_p += m_stride ; 00559 } 00560 *(i4 *) result_p = accum ; 00561 counter[0] = a_size ; 00562 j = 0 ; 00563 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00564 array_p += src_offset[j] ; 00565 mask_p += msk_offset[j] ; 00566 result_p += res_offset[j] ; 00567 counter[j+1]++ ; 00568 counter[j] = 0 ; 00569 j ++ ; 00570 } 00571 } 00572 } 00573 } 00574 void 00575 _MAXVAL__J( 00576 DopeVectorType *result, 00577 DopeVectorType *array, 00578 DopeVectorType *dim, 00579 DopeVectorType *mask) 00580 { 00581 char * result_p, * result_b ; 00582 char * array_p, * array_b ; 00583 char * dim_p, * dim_b ; 00584 char * mask_p, * mask_b ; 00585 00586 size_t src_extent [MAX_NARY_DIMS] ; 00587 size_t counter [MAX_NARY_DIMS] ; 00588 size_t src_offset [MAX_NARY_DIMS] ; 00589 size_t src_stride [MAX_NARY_DIMS] ; 00590 size_t src_size ; 00591 00592 size_t res_stride [MAX_NARY_DIMS] ; 00593 size_t res_offset [MAX_NARY_DIMS] ; 00594 00595 size_t msk_stride [MAX_NARY_DIMS] ; 00596 size_t msk_offset [MAX_NARY_DIMS] ; 00597 00598 int32_t ddim ; 00599 uint32_t src_rank ; 00600 uint32_t res_rank ; 00601 00602 size_t j,k,i ; 00603 size_t msk_typ_sz; 00604 00605 i8 accum ; 00606 i8 const initv = INT64_MIN ; 00607 size_t a_size,a_stride; 00608 size_t m_stride ; 00609 00610 i8 temp,new ; 00611 00612 if (mask == NULL) { /* is third arg mask or dim? */ 00613 if (dim != NULL) { 00614 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00615 mask = (DopeVectorType *) dim ; 00616 dim = NULL; 00617 } 00618 } 00619 } 00620 00621 if (dim != NULL) { 00622 ddim = read_dim(dim); 00623 } else 00624 ddim = 0 ; 00625 00626 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00627 src_rank = GET_RANK_FROM_DESC(array) - 1; 00628 00629 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00630 00631 for (i = 0 ; i <= src_rank ; i ++) 00632 counter[i] = 0 ; 00633 00634 if ((ddim > src_rank ) || (ddim < 0)) 00635 ERROR(_LELVL_ABORT,FESCIDIM); 00636 00637 res_rank = GET_RANK_FROM_DESC(result); 00638 00639 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00640 alloc_res(result,src_extent); 00641 } 00642 00643 res_stride[0] = 0; 00644 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00645 for (j = 0 ; j < res_rank ; j ++ ) { 00646 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00647 } 00648 00649 res_offset[0] = res_stride[0] ; 00650 for ( j = 1 ; j < res_rank ; j ++ ) 00651 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00652 00653 result_b = GET_ADDRESS_FROM_DESC(result); 00654 00655 if (mask != NULL) { 00656 00657 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00658 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00659 00660 if (GET_RANK_FROM_DESC(mask) == 0) { 00661 if (*mask_b) { 00662 mask = NULL; 00663 } else { 00664 src_size = 0; 00665 for (j = 0 ; j <= src_rank ; j ++) { 00666 msk_stride[j] = 0 ; 00667 msk_offset[j] = 0 ; 00668 } 00669 } 00670 00671 } else { 00672 00673 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00674 } 00675 } 00676 00677 accum = initv ; 00678 00679 if (src_size == 0 ) { 00680 for (i = 1 ; i <= src_rank ; i ++ ) 00681 if (src_extent[i] == 0) 00682 return ; 00683 } 00684 array_p = array_b ; 00685 result_p = result_b ; 00686 if (mask == NULL) { 00687 00688 a_size = src_extent[0] ; 00689 a_stride = src_stride[0] ; 00690 00691 while (counter[src_rank] < src_extent[src_rank] ) { 00692 00693 if(res_rank != 0) accum = initv ; 00694 00695 for ( i = 0 ; i < a_size ; i ++ ) { 00696 if (*(i8 *)array_p > accum ) { 00697 accum = * (i8 *)array_p ; 00698 } 00699 array_p += a_stride ; 00700 } 00701 *(i8 *) result_p = accum ; 00702 counter[0] = a_size ; 00703 j = 0 ; 00704 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00705 array_p += src_offset[j] ; 00706 result_p += res_offset[j] ; 00707 counter[j+1]++ ; 00708 counter[j] = 0 ; 00709 j ++ ; 00710 } 00711 } 00712 } else { 00713 00714 a_size = src_extent[0] ; 00715 a_stride = src_stride[0] ; 00716 m_stride = msk_stride[0] ; 00717 mask_p = mask_b ; 00718 00719 while (counter[src_rank] < src_extent[src_rank] ) { 00720 00721 if(res_rank != 0) accum = initv ; 00722 00723 for ( i = 0 ; i < a_size ; i ++ ) { 00724 if (*mask_p) { 00725 if (*(i8 *)array_p > accum ) { 00726 accum = * (i8 *)array_p ; 00727 } 00728 } 00729 array_p += a_stride ; 00730 mask_p += m_stride ; 00731 } 00732 *(i8 *) result_p = accum ; 00733 counter[0] = a_size ; 00734 j = 0 ; 00735 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00736 array_p += src_offset[j] ; 00737 mask_p += msk_offset[j] ; 00738 result_p += res_offset[j] ; 00739 counter[j+1]++ ; 00740 counter[j] = 0 ; 00741 j ++ ; 00742 } 00743 } 00744 } 00745 } 00746 void 00747 _MAXVAL__S4( 00748 DopeVectorType *result, 00749 DopeVectorType *array, 00750 DopeVectorType *dim, 00751 DopeVectorType *mask) 00752 { 00753 char * result_p, * result_b ; 00754 char * array_p, * array_b ; 00755 char * dim_p, * dim_b ; 00756 char * mask_p, * mask_b ; 00757 00758 size_t src_extent [MAX_NARY_DIMS] ; 00759 size_t counter [MAX_NARY_DIMS] ; 00760 size_t src_offset [MAX_NARY_DIMS] ; 00761 size_t src_stride [MAX_NARY_DIMS] ; 00762 size_t src_size ; 00763 00764 size_t res_stride [MAX_NARY_DIMS] ; 00765 size_t res_offset [MAX_NARY_DIMS] ; 00766 00767 size_t msk_stride [MAX_NARY_DIMS] ; 00768 size_t msk_offset [MAX_NARY_DIMS] ; 00769 00770 int32_t ddim ; 00771 uint32_t src_rank ; 00772 uint32_t res_rank ; 00773 00774 size_t j,k,i ; 00775 size_t msk_typ_sz; 00776 00777 r4 accum ; 00778 r4 const initv = -HUGE_REAL4_F90 ; 00779 size_t a_size,a_stride; 00780 size_t m_stride ; 00781 00782 r4 temp,new ; 00783 00784 if (mask == NULL) { /* is third arg mask or dim? */ 00785 if (dim != NULL) { 00786 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00787 mask = (DopeVectorType *) dim ; 00788 dim = NULL; 00789 } 00790 } 00791 } 00792 00793 if (dim != NULL) { 00794 ddim = read_dim(dim); 00795 } else 00796 ddim = 0 ; 00797 00798 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00799 src_rank = GET_RANK_FROM_DESC(array) - 1; 00800 00801 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00802 00803 for (i = 0 ; i <= src_rank ; i ++) 00804 counter[i] = 0 ; 00805 00806 if ((ddim > src_rank ) || (ddim < 0)) 00807 ERROR(_LELVL_ABORT,FESCIDIM); 00808 00809 res_rank = GET_RANK_FROM_DESC(result); 00810 00811 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00812 alloc_res(result,src_extent); 00813 } 00814 00815 res_stride[0] = 0; 00816 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00817 for (j = 0 ; j < res_rank ; j ++ ) { 00818 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00819 } 00820 00821 res_offset[0] = res_stride[0] ; 00822 for ( j = 1 ; j < res_rank ; j ++ ) 00823 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00824 00825 result_b = GET_ADDRESS_FROM_DESC(result); 00826 00827 if (mask != NULL) { 00828 00829 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 00830 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 00831 00832 if (GET_RANK_FROM_DESC(mask) == 0) { 00833 if (*mask_b) { 00834 mask = NULL; 00835 } else { 00836 src_size = 0; 00837 for (j = 0 ; j <= src_rank ; j ++) { 00838 msk_stride[j] = 0 ; 00839 msk_offset[j] = 0 ; 00840 } 00841 } 00842 00843 } else { 00844 00845 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 00846 } 00847 } 00848 00849 accum = initv ; 00850 00851 if (src_size == 0 ) { 00852 for (i = 1 ; i <= src_rank ; i ++ ) 00853 if (src_extent[i] == 0) 00854 return ; 00855 } 00856 array_p = array_b ; 00857 result_p = result_b ; 00858 if (mask == NULL) { 00859 00860 a_size = src_extent[0] ; 00861 a_stride = src_stride[0] ; 00862 00863 while (counter[src_rank] < src_extent[src_rank] ) { 00864 00865 if(res_rank != 0) accum = initv ; 00866 00867 for ( i = 0 ; i < a_size ; i ++ ) { 00868 if (*(r4 *)array_p > accum ) { 00869 accum = * (r4 *)array_p ; 00870 } 00871 array_p += a_stride ; 00872 } 00873 *(r4 *) result_p = accum ; 00874 counter[0] = a_size ; 00875 j = 0 ; 00876 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00877 array_p += src_offset[j] ; 00878 result_p += res_offset[j] ; 00879 counter[j+1]++ ; 00880 counter[j] = 0 ; 00881 j ++ ; 00882 } 00883 } 00884 } else { 00885 00886 a_size = src_extent[0] ; 00887 a_stride = src_stride[0] ; 00888 m_stride = msk_stride[0] ; 00889 mask_p = mask_b ; 00890 00891 while (counter[src_rank] < src_extent[src_rank] ) { 00892 00893 if(res_rank != 0) accum = initv ; 00894 00895 for ( i = 0 ; i < a_size ; i ++ ) { 00896 if (*mask_p) { 00897 if (*(r4 *)array_p > accum ) { 00898 accum = * (r4 *)array_p ; 00899 } 00900 } 00901 array_p += a_stride ; 00902 mask_p += m_stride ; 00903 } 00904 *(r4 *) result_p = accum ; 00905 counter[0] = a_size ; 00906 j = 0 ; 00907 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00908 array_p += src_offset[j] ; 00909 mask_p += msk_offset[j] ; 00910 result_p += res_offset[j] ; 00911 counter[j+1]++ ; 00912 counter[j] = 0 ; 00913 j ++ ; 00914 } 00915 } 00916 } 00917 } 00918 void 00919 _MAXVAL__S( 00920 DopeVectorType *result, 00921 DopeVectorType *array, 00922 DopeVectorType *dim, 00923 DopeVectorType *mask) 00924 { 00925 char * result_p, * result_b ; 00926 char * array_p, * array_b ; 00927 char * dim_p, * dim_b ; 00928 char * mask_p, * mask_b ; 00929 00930 size_t src_extent [MAX_NARY_DIMS] ; 00931 size_t counter [MAX_NARY_DIMS] ; 00932 size_t src_offset [MAX_NARY_DIMS] ; 00933 size_t src_stride [MAX_NARY_DIMS] ; 00934 size_t src_size ; 00935 00936 size_t res_stride [MAX_NARY_DIMS] ; 00937 size_t res_offset [MAX_NARY_DIMS] ; 00938 00939 size_t msk_stride [MAX_NARY_DIMS] ; 00940 size_t msk_offset [MAX_NARY_DIMS] ; 00941 00942 int32_t ddim ; 00943 uint32_t src_rank ; 00944 uint32_t res_rank ; 00945 00946 size_t j,k,i ; 00947 size_t msk_typ_sz; 00948 00949 r8 accum ; 00950 r8 const initv = -HUGE_REAL8_F90 ; 00951 size_t a_size,a_stride; 00952 size_t m_stride ; 00953 00954 r8 temp,new ; 00955 00956 if (mask == NULL) { /* is third arg mask or dim? */ 00957 if (dim != NULL) { 00958 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 00959 mask = (DopeVectorType *) dim ; 00960 dim = NULL; 00961 } 00962 } 00963 } 00964 00965 if (dim != NULL) { 00966 ddim = read_dim(dim); 00967 } else 00968 ddim = 0 ; 00969 00970 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 00971 src_rank = GET_RANK_FROM_DESC(array) - 1; 00972 00973 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 00974 00975 for (i = 0 ; i <= src_rank ; i ++) 00976 counter[i] = 0 ; 00977 00978 if ((ddim > src_rank ) || (ddim < 0)) 00979 ERROR(_LELVL_ABORT,FESCIDIM); 00980 00981 res_rank = GET_RANK_FROM_DESC(result); 00982 00983 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00984 alloc_res(result,src_extent); 00985 } 00986 00987 res_stride[0] = 0; 00988 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 00989 for (j = 0 ; j < res_rank ; j ++ ) { 00990 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 00991 } 00992 00993 res_offset[0] = res_stride[0] ; 00994 for ( j = 1 ; j < res_rank ; j ++ ) 00995 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 00996 00997 result_b = GET_ADDRESS_FROM_DESC(result); 00998 00999 if (mask != NULL) { 01000 01001 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 01002 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 01003 01004 if (GET_RANK_FROM_DESC(mask) == 0) { 01005 if (*mask_b) { 01006 mask = NULL; 01007 } else { 01008 src_size = 0; 01009 for (j = 0 ; j <= src_rank ; j ++) { 01010 msk_stride[j] = 0 ; 01011 msk_offset[j] = 0 ; 01012 } 01013 } 01014 01015 } else { 01016 01017 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 01018 } 01019 } 01020 01021 accum = initv ; 01022 01023 if (src_size == 0 ) { 01024 for (i = 1 ; i <= src_rank ; i ++ ) 01025 if (src_extent[i] == 0) 01026 return ; 01027 } 01028 array_p = array_b ; 01029 result_p = result_b ; 01030 if (mask == NULL) { 01031 01032 a_size = src_extent[0] ; 01033 a_stride = src_stride[0] ; 01034 01035 while (counter[src_rank] < src_extent[src_rank] ) { 01036 01037 if(res_rank != 0) accum = initv ; 01038 01039 for ( i = 0 ; i < a_size ; i ++ ) { 01040 if (*(r8 *)array_p > accum ) { 01041 accum = * (r8 *)array_p ; 01042 } 01043 array_p += a_stride ; 01044 } 01045 *(r8 *) result_p = accum ; 01046 counter[0] = a_size ; 01047 j = 0 ; 01048 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01049 array_p += src_offset[j] ; 01050 result_p += res_offset[j] ; 01051 counter[j+1]++ ; 01052 counter[j] = 0 ; 01053 j ++ ; 01054 } 01055 } 01056 } else { 01057 01058 a_size = src_extent[0] ; 01059 a_stride = src_stride[0] ; 01060 m_stride = msk_stride[0] ; 01061 mask_p = mask_b ; 01062 01063 while (counter[src_rank] < src_extent[src_rank] ) { 01064 01065 if(res_rank != 0) accum = initv ; 01066 01067 for ( i = 0 ; i < a_size ; i ++ ) { 01068 if (*mask_p) { 01069 if (*(r8 *)array_p > accum ) { 01070 accum = * (r8 *)array_p ; 01071 } 01072 } 01073 array_p += a_stride ; 01074 mask_p += m_stride ; 01075 } 01076 *(r8 *) result_p = accum ; 01077 counter[0] = a_size ; 01078 j = 0 ; 01079 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01080 array_p += src_offset[j] ; 01081 mask_p += msk_offset[j] ; 01082 result_p += res_offset[j] ; 01083 counter[j+1]++ ; 01084 counter[j] = 0 ; 01085 j ++ ; 01086 } 01087 } 01088 } 01089 } 01090 void 01091 _MAXVAL__D( 01092 DopeVectorType *result, 01093 DopeVectorType *array, 01094 DopeVectorType *dim, 01095 DopeVectorType *mask) 01096 { 01097 char * result_p, * result_b ; 01098 char * array_p, * array_b ; 01099 char * dim_p, * dim_b ; 01100 char * mask_p, * mask_b ; 01101 01102 size_t src_extent [MAX_NARY_DIMS] ; 01103 size_t counter [MAX_NARY_DIMS] ; 01104 size_t src_offset [MAX_NARY_DIMS] ; 01105 size_t src_stride [MAX_NARY_DIMS] ; 01106 size_t src_size ; 01107 01108 size_t res_stride [MAX_NARY_DIMS] ; 01109 size_t res_offset [MAX_NARY_DIMS] ; 01110 01111 size_t msk_stride [MAX_NARY_DIMS] ; 01112 size_t msk_offset [MAX_NARY_DIMS] ; 01113 01114 int32_t ddim ; 01115 uint32_t src_rank ; 01116 uint32_t res_rank ; 01117 01118 size_t j,k,i ; 01119 size_t msk_typ_sz; 01120 01121 r16 accum ; 01122 r16 const initv = -HUGE_REAL16_F90 ; 01123 size_t a_size,a_stride; 01124 size_t m_stride ; 01125 01126 r16 temp,new ; 01127 01128 if (mask == NULL) { /* is third arg mask or dim? */ 01129 if (dim != NULL) { 01130 if (GET_DV_LOGICAL_FROM_DESC(dim)) { 01131 mask = (DopeVectorType *) dim ; 01132 dim = NULL; 01133 } 01134 } 01135 } 01136 01137 if (dim != NULL) { 01138 ddim = read_dim(dim); 01139 } else 01140 ddim = 0 ; 01141 01142 array_b = (char *) GET_ADDRESS_FROM_DESC(array) ; 01143 src_rank = GET_RANK_FROM_DESC(array) - 1; 01144 01145 src_size = read_source_desc(array, src_extent, src_stride, src_offset, ddim); 01146 01147 for (i = 0 ; i <= src_rank ; i ++) 01148 counter[i] = 0 ; 01149 01150 if ((ddim > src_rank ) || (ddim < 0)) 01151 ERROR(_LELVL_ABORT,FESCIDIM); 01152 01153 res_rank = GET_RANK_FROM_DESC(result); 01154 01155 if (!GET_ASSOCIATED_FROM_DESC(result)) { 01156 alloc_res(result,src_extent); 01157 } 01158 01159 res_stride[0] = 0; 01160 for (j = 0 ; j <= src_rank; j ++ ) res_offset[j] = 0 ; 01161 for (j = 0 ; j < res_rank ; j ++ ) { 01162 res_stride[j] = GET_STRIDE_FROM_DESC(result,j) ; 01163 } 01164 01165 res_offset[0] = res_stride[0] ; 01166 for ( j = 1 ; j < res_rank ; j ++ ) 01167 res_offset[j] = res_stride[j] - (res_stride[j-1]*(src_extent[j])) ; 01168 01169 result_b = GET_ADDRESS_FROM_DESC(result); 01170 01171 if (mask != NULL) { 01172 01173 msk_typ_sz = GET_ELEMENT_SZ_FROM_DESC(mask); 01174 mask_b = (char *) GET_ADDRESS_FROM_DESC(mask) + OFFSET_TO_TF_BYTE(msk_typ_sz) ; 01175 01176 if (GET_RANK_FROM_DESC(mask) == 0) { 01177 if (*mask_b) { 01178 mask = NULL; 01179 } else { 01180 src_size = 0; 01181 for (j = 0 ; j <= src_rank ; j ++) { 01182 msk_stride[j] = 0 ; 01183 msk_offset[j] = 0 ; 01184 } 01185 } 01186 01187 } else { 01188 01189 get_offset_and_stride(mask, src_extent, msk_stride, msk_offset, ddim); 01190 } 01191 } 01192 01193 accum = initv ; 01194 01195 if (src_size == 0 ) { 01196 for (i = 1 ; i <= src_rank ; i ++ ) 01197 if (src_extent[i] == 0) 01198 return ; 01199 } 01200 array_p = array_b ; 01201 result_p = result_b ; 01202 if (mask == NULL) { 01203 01204 a_size = src_extent[0] ; 01205 a_stride = src_stride[0] ; 01206 01207 while (counter[src_rank] < src_extent[src_rank] ) { 01208 01209 if(res_rank != 0) accum = initv ; 01210 01211 for ( i = 0 ; i < a_size ; i ++ ) { 01212 if (*(r16 *)array_p > accum ) { 01213 accum = * (r16 *)array_p ; 01214 } 01215 array_p += a_stride ; 01216 } 01217 *(r16 *) result_p = accum ; 01218 counter[0] = a_size ; 01219 j = 0 ; 01220 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01221 array_p += src_offset[j] ; 01222 result_p += res_offset[j] ; 01223 counter[j+1]++ ; 01224 counter[j] = 0 ; 01225 j ++ ; 01226 } 01227 } 01228 } else { 01229 01230 a_size = src_extent[0] ; 01231 a_stride = src_stride[0] ; 01232 m_stride = msk_stride[0] ; 01233 mask_p = mask_b ; 01234 01235 while (counter[src_rank] < src_extent[src_rank] ) { 01236 01237 if(res_rank != 0) accum = initv ; 01238 01239 for ( i = 0 ; i < a_size ; i ++ ) { 01240 if (*mask_p) { 01241 if (*(r16 *)array_p > accum ) { 01242 accum = * (r16 *)array_p ; 01243 } 01244 } 01245 array_p += a_stride ; 01246 mask_p += m_stride ; 01247 } 01248 *(r16 *) result_p = accum ; 01249 counter[0] = a_size ; 01250 j = 0 ; 01251 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 01252 array_p += src_offset[j] ; 01253 mask_p += msk_offset[j] ; 01254 result_p += res_offset[j] ; 01255 counter[j+1]++ ; 01256 counter[j] = 0 ; 01257 j ++ ; 01258 } 01259 } 01260 } 01261 } 01262 static void 01263 alloc_res(DopeVectorType * result, 01264 size_t src_extent[MAX_NARY_DIMS]) 01265 { 01266 size_t tot_ext ; 01267 size_t str_sz ; 01268 size_t nbytes ; 01269 size_t esz ; 01270 int32_t res_rank ; 01271 char *p = NULL ; 01272 int32_t i ; 01273 01274 SET_ADDRESS_IN_DESC(result,NULL); 01275 SET_ORIG_BS_IN_DESC(result,NULL) ; 01276 SET_ORIG_SZ_IN_DESC(result,0) ; 01277 01278 res_rank = GET_RANK_FROM_DESC(result); 01279 tot_ext = 1 ; 01280 esz = GET_ALEN_FROM_DESC(result) >> 3 ; 01281 nbytes = esz ; 01282 str_sz = MK_STRIDE(FALSE,esz); 01283 01284 for ( i = 0 ; i < res_rank ; i ++) { 01285 SET_LBOUND_IN_DESC(result,i,1); 01286 SET_EXTENT_IN_DESC(result,i,src_extent[i+1]); 01287 SET_STRMULT_IN_DESC(result,i,tot_ext * str_sz ); 01288 tot_ext *= src_extent[i+1] ; 01289 } 01290 nbytes *= tot_ext; 01291 if (nbytes > 0 ) { 01292 p = (void *) malloc (nbytes); 01293 if (p == NULL) 01294 ERROR(_LELVL_ABORT, FENOMEMY); 01295 01296 SET_ADDRESS_IN_DESC(result,p); 01297 } 01298 SET_ASSOCIATED_IN_DESC(result); 01299 SET_CONTIG_IN_DESC(result); 01300 SET_ORIG_BS_IN_DESC(result,p) ; 01301 SET_ORIG_SZ_IN_DESC(result,nbytes * 8) ; 01302 } 01303 01304 static int32_t 01305 read_dim(DopeVectorType * dim) 01306 { 01307 int32_t ddim ; 01308 char * dim_p ; 01309 01310 dim_p = (char *) GET_ADDRESS_FROM_DESC(dim) ; 01311 01312 switch (GET_ELEMENT_SZ_FROM_DESC(dim)) { 01313 case sizeof(int8_t): 01314 ddim = * (int8_t *) dim_p ; 01315 break; 01316 01317 case sizeof(int16_t): 01318 ddim = * (int16_t *) dim_p ; 01319 break; 01320 01321 case sizeof(int32_t): 01322 ddim = * (int32_t *) dim_p ; 01323 break; 01324 01325 case sizeof(int64_t): 01326 ddim = * (int64_t *) dim_p ; 01327 break; 01328 } 01329 01330 return (ddim - 1) ; 01331 } 01332 01333 static size_t 01334 read_source_desc(DopeVectorType * array, 01335 size_t src_extent[MAX_NARY_DIMS], 01336 size_t src_stride[MAX_NARY_DIMS], 01337 size_t src_offset[MAX_NARY_DIMS], 01338 int32_t ddim) 01339 { 01340 int32_t src_rank ,k,j ; 01341 size_t src_size ; 01342 01343 src_extent[0] = GET_EXTENT_FROM_DESC(array,ddim) ; 01344 src_rank = GET_RANK_FROM_DESC(array); 01345 01346 src_size = src_extent[0]; 01347 01348 for ( k = 1, j = 0 ; j < src_rank ; j ++ ) { 01349 if (j != ddim ) { 01350 src_extent[k] = GET_EXTENT_FROM_DESC(array,j) ; 01351 src_size *= src_extent[k]; 01352 k++ ; 01353 } 01354 } 01355 get_offset_and_stride(array, src_extent, src_stride, src_offset, ddim); 01356 01357 return src_size; 01358 } 01359 01360 static void 01361 get_offset_and_stride(DopeVectorType * array, 01362 size_t src_extent[MAX_NARY_DIMS], 01363 size_t src_stride[MAX_NARY_DIMS], 01364 size_t src_offset[MAX_NARY_DIMS], 01365 int32_t ddim) 01366 { 01367 01368 int32_t src_rank ,k,j ; 01369 01370 src_stride[0] = GET_STRIDE_FROM_DESC(array,ddim) ; 01371 src_offset[0] = 0; 01372 src_rank = GET_RANK_FROM_DESC(array); 01373 01374 for ( k = 1, j = 0 ; j < src_rank ; j ++ ) { 01375 if (j != ddim ) { 01376 src_stride[k] = GET_STRIDE_FROM_DESC(array,j) ; 01377 src_offset[k-1] = src_stride[k] - (src_stride [k-1] * (src_extent[k-1])) ; 01378 k++ ; 01379 } 01380 } 01381 }