00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
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 _MINVAL__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_MAX ;
00091 size_t a_size,a_stride;
00092 size_t m_stride ;
00093
00094 i1 temp,new ;
00095
00096 if (mask == NULL) {
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 _MINVAL__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_MAX ;
00263 size_t a_size,a_stride;
00264 size_t m_stride ;
00265
00266 i2 temp,new ;
00267
00268 if (mask == NULL) {
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 _MINVAL__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_MAX ;
00435 size_t a_size,a_stride;
00436 size_t m_stride ;
00437
00438 i4 temp,new ;
00439
00440 if (mask == NULL) {
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 _MINVAL__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_MAX ;
00607 size_t a_size,a_stride;
00608 size_t m_stride ;
00609
00610 i8 temp,new ;
00611
00612 if (mask == NULL) {
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 _MINVAL__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) {
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 _MINVAL__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) {
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 _MINVAL__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) {
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 }
