nco: nco/ncap.h File Reference

00281 {
00282   /* Purpose: Convert scv_sct to ptr_unn
00283      malloc() appropriate space for single type
00284      NB: Does not work on strings */
00285   ptr_unn val;
00286   nc_type type=scv.type;
00287   val.vp=(void *)nco_malloc(nco_typ_lng(type));
00288   (void)cast_void_nctype(type,&val);
00289   
00290   switch(type){
00291   case NC_FLOAT: *val.fp=scv.val.f; break;
00292   case NC_DOUBLE: *val.dp=scv.val.d; break;
00293   case NC_INT: *val.lp=scv.val.l; break;
00294   case NC_SHORT: *val.sp=scv.val.s; break;
00295   case NC_BYTE: *val.bp=scv.val.b; break;
00296   case NC_CHAR: break; /* do nothing */
00297   default: nco_dfl_case_nc_type_err(); break;
00298   } /* end switch */
00299   (void)cast_nctype_void(type,&val);
00300   return val;
00301 } /* end ncap_scv_2_ptr_unn() */

00827 {
00828   /* Purpose: Find the absolute value of a scalar value */
00829 
00830 #ifndef __GNUG__ 
00831   extern float fabsf(float); /* Sun math.h does not include fabsf() prototype */
00832 #endif   
00833 
00834 
00835   
00836   scv_sct scv_out;
00837   scv_out.type=scv.type;
00838   
00839   
00840   switch(scv.type){ 
00841   case NC_BYTE:
00842     scv_out.val.b=((scv.val.b >= 0) ? scv.val.b : -scv.val.b);
00843     break;
00844   case NC_CHAR:
00845     /* Do nothing */
00846     break;
00847   case NC_SHORT:
00848     scv_out.val.s=((scv.val.s >= 0) ? scv.val.s : -scv.val.s);
00849     break;
00850   case NC_INT:
00851     scv_out.val.l=labs(scv.val.l); /* int abs(int), long labs(long) */
00852     break;            
00853   case NC_FLOAT:
00854     scv_out.val.f=fabsf(scv.val.f);
00855     break;
00856   case NC_DOUBLE:
00857     scv_out.val.d=fabs(scv.val.d);
00858     break;
00859   default: nco_dfl_case_nc_type_err(); break;    
00860   } /* end switch */
00861   return scv_out;
00862 } /* end ncap_scv_abs */

00754 {
00755   /* Purpose: Calculate (scv_1 op scv_2) NB: Scalar values must be of same type */
00756   
00757   /* http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
00758      __GNUC__ : Defined by gcc 
00759      __GNUG__ : Defined by g++, equivalent to (__GNUC__ && __cplusplus) */
00760 
00761 #ifndef __GNUG__ 
00762   extern float fmodf(float,float); /* Cannot insert fmodf in ncap_sym_init() because it takes two arguments TODO #20 */
00763   extern float fabsf(float); /* Sun math.h does not include fabsf() prototype */
00764 #endif   /* __GNUG__ */
00765   
00766   scv_sct scv_out;
00767   scv_out.type=scv_1.type;
00768 
00769   /*
00770   if(scv_1.undefined || scv_2.undefined ) {
00771     scv_out.undefined=True;
00772     return scv_out;
00773   }
00774   */
00775   switch(scv_out.type){ 
00776   case NC_BYTE:
00777     switch(op){
00778     case '+': scv_out.val.b=scv_1.val.b+scv_2.val.b;break;
00779     case '-': scv_out.val.b=scv_1.val.b-scv_2.val.b;break;
00780     case '/': scv_out.val.b=scv_1.val.b/scv_2.val.b;break;
00781     case '*': scv_out.val.b=scv_1.val.b*scv_2.val.b;break;
00782     case '%': scv_out.val.b=scv_1.val.b%scv_2.val.b;break;
00783     } break;
00784   case NC_CHAR:
00785     /* Do nothing */
00786     break;
00787   case NC_SHORT:
00788     switch(op){
00789     case '+': scv_out.val.s=scv_1.val.s+scv_2.val.s;break;
00790     case '-': scv_out.val.s=scv_1.val.s-scv_2.val.s;break;
00791     case '/': scv_out.val.s=scv_1.val.s/scv_2.val.s;break;
00792     case '*': scv_out.val.s=scv_1.val.s*scv_2.val.s;break;
00793     case '%': scv_out.val.s=scv_1.val.s%scv_2.val.s;break;
00794     } break;
00795   case NC_INT:
00796     switch(op){
00797     case '+': scv_out.val.l=scv_1.val.l+scv_2.val.l;break;
00798     case '-': scv_out.val.l=scv_1.val.l-scv_2.val.l;break;
00799     case '/': scv_out.val.l=scv_1.val.l/scv_2.val.l;break;
00800     case '*': scv_out.val.l=scv_1.val.l*scv_2.val.l;break;
00801     case '%': scv_out.val.l=scv_1.val.l%scv_2.val.l;break;
00802     } break;
00803   case NC_FLOAT:
00804     switch(op){
00805     case '+': scv_out.val.f=scv_1.val.f+scv_2.val.f;break;
00806     case '-': scv_out.val.f=scv_1.val.f-scv_2.val.f;break;
00807     case '/': scv_out.val.f=scv_1.val.f/scv_2.val.f;break;
00808     case '*': scv_out.val.f=scv_1.val.f*scv_2.val.f;break;
00809     case '%': scv_out.val.f=fmodf(scv_1.val.f,fabsf(scv_2.val.f));break;
00810     } break;
00811   case NC_DOUBLE:
00812     switch(op){
00813     case '+': scv_out.val.d=scv_1.val.d+scv_2.val.d;break;
00814     case '-': scv_out.val.d=scv_1.val.d-scv_2.val.d;break;
00815     case '/': scv_out.val.d=scv_1.val.d/scv_2.val.d;break;
00816     case '*': scv_out.val.d=scv_1.val.d*scv_2.val.d;break;
00817     case '%': scv_out.val.d=fmod(scv_1.val.d,fabs(scv_2.val.d));break;
00818     } break;
00819   default: nco_dfl_case_nc_type_err(); break;
00820   }/* end switch */    
00821   
00822   return scv_out;
00823 } /* end ncap_scv_clc_type */

00866 {
00867   switch(scv->type){ 
00868   case NC_BYTE:
00869     scv->val.b=-scv->val.b; 
00870     break;
00871   case NC_CHAR:
00872     /* Do nothing */
00873     break;
00874   case NC_SHORT:
00875     scv->val.s=-scv->val.s;
00876     break;
00877   case NC_INT:
00878     scv->val.l=-scv->val.l;
00879     break;            
00880   case NC_FLOAT:
00881     scv->val.f=-scv->val.f;
00882     break;
00883   case NC_DOUBLE:
00884     scv->val.d=-scv->val.d;
00885     break;
00886   default: nco_dfl_case_nc_type_err(); break;  
00887   } /* end switch */    
00888   return scv->type;
00889 } /* end ncap_scv_minus() */

00658 {
00659   /* Purpose: Divide scv by value of each element in var */
00660   if(var->undefined) return var;
00661 
00662   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00663 
00664   /* deal with inital scan */
00665   if(var->val.vp==NULL) return var; 
00666 
00667 
00668   (void)scv_var_dvd(var->type,var->sz,var->has_mss_val,var->mss_val,&scv,var->val);
00669   return var;
00670 } /* end ncap_scv_var_dvd */

00689 {
00690   /* Purpose: Modulus of scv with each element of var */
00691   if(var->undefined) return var;
00692 
00693   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00694 
00695   /* deal with inital scan */
00696   if(var->val.vp==NULL) return var; 
00697 
00698   (void)scv_var_mod(var->type,var->sz,var->has_mss_val,var->mss_val,&scv,var->val);
00699   return var;
00700 } /* ncap_var_scv_mod */

00720 {
00721   /* Purpose: Empower each element in scv by var */
00722   /* Promote scv and var to NC_FLOAT if necessary since C has no integer empowerment 
00723      This reduces type conversion warnings (it is not done to avoid overflow) */
00724   if(var->undefined) return var;
00725 
00726   if(var->type < NC_FLOAT) var=nco_var_cnf_typ((nc_type)NC_FLOAT,var);
00727   (void)nco_scv_cnf_typ(var->type,&scv);
00728 
00729   /* deal with inital scan */
00730   if(var->val.vp==NULL) return var; 
00731 
00732   (void)scv_var_pwr(var->type,var->sz,var->has_mss_val,var->mss_val,&scv,var->val);
00733   return var;
00734 } /* end ncap_var_scv_pwr */

00237 { 
00238   /* Purpose: Allocate space for sym_sct then initialize */
00239   sym_sct *symbol;
00240   symbol=(sym_sct *)nco_malloc(sizeof(sym_sct));
00241   symbol->nm=(char *)strdup(sym_nm);
00242   symbol->fnc_dbl=fnc_dbl;
00243   symbol->fnc_flt=fnc_flt;
00244   return symbol;
00245 } /* end ncap_sym_init() */

00381                            : Find absolute value of each element of var */
00382 var_sct *var)    /* I/O [sct] input variable */
00383 {
00384 
00385   if(var->undefined) return var;
00386 
00387   /* deal with inital scan */
00388   if(var->val.vp==NULL) return var; 
00389 
00390   (void)nco_var_abs(var->type,var->sz,var->has_mss_val,var->mss_val,var->val);
00391   return var;
00392 } /* end ncap_var_abs */

00326 {
00327   /* Purpose: Evaluate fnc_dbl(var) or fnc_flt(var) for each value in variable
00328      Float and double functions are in app */
00329   long idx;
00330   long sz;
00331   ptr_unn op1;
00332 
00333   if(var_in->undefined) return var_in;
00334   
00335   
00336   /* Promote variable to NC_FLOAT */
00337   if(var_in->type < NC_FLOAT) var_in=nco_var_cnf_typ((nc_type)NC_FLOAT,var_in);
00338 
00339   /* deal with inital scan */
00340   if(var_in->val.vp==NULL) return var_in; 
00341   
00342 
00343   
00344   op1=var_in->val;
00345   sz=var_in->sz;
00346   (void)cast_void_nctype(var_in->type,&op1);
00347   if(var_in->has_mss_val) (void)cast_void_nctype(var_in->type,&(var_in->mss_val));
00348   
00349   switch(var_in->type){ 
00350   case NC_DOUBLE: {
00351     if(!var_in->has_mss_val){
00352       for(idx=0;idx<sz;idx++) op1.dp[idx]=(*(app->fnc_dbl))(op1.dp[idx]);
00353     }else{
00354       double mss_val_dbl=*(var_in->mss_val.dp); /* Temporary variable reduces de-referencing */
00355       for(idx=0;idx<sz;idx++){
00356         if(op1.dp[idx] != mss_val_dbl) op1.dp[idx]=(*(app->fnc_dbl))(op1.dp[idx]);
00357       } /* end for */
00358     } /* end else */
00359     break;
00360   }
00361   case NC_FLOAT: {
00362     if(!var_in->has_mss_val){
00363       for(idx=0;idx<sz;idx++) op1.fp[idx]=(*(app->fnc_flt))(op1.fp[idx]);
00364     }else{
00365       float mss_val_flt=*(var_in->mss_val.fp); /* Temporary variable reduces de-referencing */
00366       for(idx=0;idx<sz;idx++){
00367         if(op1.fp[idx] != mss_val_flt) op1.fp[idx]=(*(app->fnc_flt))(op1.fp[idx]);
00368       } /* end for */
00369     } /* end else */
00370     break;
00371   }
00372   default: nco_dfl_case_nc_type_err(); break;
00373   }/* end switch */
00374   
00375   if(var_in->has_mss_val) (void)cast_nctype_void(var_in->type,&(var_in->mss_val));
00376   return var_in;
00377 } /* end ncap_var_fnc() */

00017 {
00018   /* Purpose: Initialize variable structure, retrieve variable values from disk
00019      Parser calls ncap_var_init() when it encounters a new RHS variable */
00020   /* const char fnc_nm[]="ncap_var_init()"; *//* [sng] Function name */
00021 
00022   int idx;
00023   int jdx;
00024   int nbr_dmn_var;
00025   int *dim_id=NULL;
00026   int var_id;
00027   int rcd;
00028   int fl_id;
00029 
00030   bool DEF_VAR=False;
00031 
00032   dmn_sct *dmn_in; 
00033   dmn_sct **dim_new=NULL_CEWI;
00034   
00035   var_sct var_lkp;
00036   var_sct *var;
00037   var_sct *var_lst;  
00038 
00039   /* Several possiblilties here:
00040      var NOT in I or O
00041      var in I
00042      var in O (defined and filled)
00043      var in 0 (defined but empty)
00044 
00045      Must handle case var in I, var in O (defined & empty) with care
00046      This occurs when var is on LHS and RHS, e.g., two=two^6
00047 
00048      INITIAL SCAN
00049      check var list for var -- 
00050      if present fill with nulls and return
00051      Not present check output then input
00052      
00053      FINAL SCAN
00054      check var list for var -- 
00055      if present & defined + filled return var from output
00056      if present & defined + unfilled reurn var from input if defined
00057      Not present check output then input */     
00058      
00059   var_lkp.nm=strdup(var_nm);
00060   var_lst=ncap_var_lookup(&var_lkp,((prs_sct*)prs_arg),False);
00061   (void)nco_free(var_lkp.nm);
00062 
00063   if(prs_arg->ntl_scn && var_lst){
00064     var=nco_var_dpl(var_lst);
00065     var->val.vp=NULL;
00066     return var; 
00067   } /* endif */
00068 
00069   /* Check if var in list has been defined but NOT filled */
00070   if(!prs_arg->ntl_scn && var_lst && var_lst->sz >0 ) DEF_VAR=True; 
00071 
00072   /* Check output file for var */  
00073   rcd=nco_inq_varid_flg(prs_arg->out_id,var_nm,&var_id);
00074   if(rcd == NC_NOERR && !DEF_VAR){
00075     fl_id=prs_arg->out_id;
00076   }else{
00077     /* Check input file for ID */
00078     rcd=nco_inq_varid_flg(prs_arg->in_id,var_nm,&var_id);
00079     if(rcd != NC_NOERR){
00080       /* Return NULL if variable not in input or output file */
00081       (void)fprintf(stderr,"WARNING unable to find %s in %s or %s\n",var_nm,prs_arg->fl_in,prs_arg->fl_out);    
00082       return (var_sct *)NULL;
00083     } /* end if */
00084     
00085     /* Find dimensions used in var
00086        Learn which are not already in output list prs_arg->dmn_out and output file
00087        Add these to output list and output file */
00088     (void)nco_redef(prs_arg->out_id);
00089     fl_id=prs_arg->in_id;
00090     
00091     (void)nco_inq_varndims(fl_id,var_id,&nbr_dmn_var);
00092     if(nbr_dmn_var>0){
00093       dim_id=(int *)nco_malloc(nbr_dmn_var*sizeof(int));
00094       
00095       (void)nco_inq_vardimid(fl_id,var_id,dim_id);
00096       for(idx=0;idx<nbr_dmn_var;idx++) 
00097         for(jdx=0;jdx<prs_arg->nbr_dmn_in;jdx++){
00098           
00099           /* De-reference */
00100           dmn_in=prs_arg->dmn_in[jdx];
00101           if(dim_id[idx] != dmn_in->id || dmn_in->xrf) continue;
00102           
00103           /* Define new dimension in (prs_arg->dmn_out) */ 
00104           dim_new=nco_dmn_out_grow(prs_arg);
00105           *dim_new=nco_dmn_dpl(dmn_in);
00106           (void)nco_dmn_xrf(*dim_new,dmn_in);
00107           /* Write new dimension to output file */
00108           (void)nco_dmn_dfn(prs_arg->fl_out,prs_arg->out_id,dim_new,1);
00109           if(dbg_lvl_get() > 2) (void)fprintf(stderr,"%s: DEBUG Found new dimension %s in input variable %s in file %s. Defining dimension %s in output file %s\n",prg_nm_get(),(*dim_new)->nm,var_nm,prs_arg->fl_in,(*dim_new)->nm,prs_arg->fl_out);
00110           break;
00111         } /* end loop over dimensions in current output dimension list */
00112       (void)nco_free(dim_id);
00113     } /* end loop over dimension in current input variable */
00114     (void)nco_enddef(prs_arg->out_id); 
00115     
00116   } /* end else */
00117   
00118   if(dbg_lvl_get() > 2) (void)fprintf(stderr,"%s: parser VAR action called ncap_var_init() to retrieve %s from disk\n",prg_nm_get(),var_nm);
00119   var=nco_var_fll(fl_id,var_id,var_nm,*(prs_arg->dmn_out),*(prs_arg->nbr_dmn_out));
00120   /*  var->nm=(char *)nco_malloc((strlen(var_nm)+1UL)*sizeof(char));
00121   (void)strcpy(var->nm,var_nm); */
00122 
00123   /* Tally is not required yet since ncap does not perform cross-file operations (yet) */
00124   /* var->tally=(long *)nco_malloc_dbg(var->sz*sizeof(long),"Unable to malloc() tally buffer in variable initialization",fnc_nm);
00125       (void)nco_zero_long(var->sz,var->tally); */
00126   var->tally=(long *)NULL;
00127 
00128   /* Retrieve variable values from disk into memory */
00129   if(prs_arg->ntl_scn) {
00130     var->val.vp=(void*)NULL;
00131   }else{
00132     (void)nco_var_get(fl_id,var);
00133   } /* end else */
00134   /* (void)nco_var_free(var_nm);*/
00135   /* (void)nco_free(var_nm->nm);*/
00136   /* var=nco_var_upk(var); */
00137   return var;
00138 } /* end ncap_var_init() */

00596 {
00597   /* Purpose: add the value in scv to each element of var */
00598 
00599   if(var->undefined) return var;
00600 
00601   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00602 
00603   /* deal with inital scan */
00604   if(var->val.vp==NULL) return var; 
00605 
00606 
00607   (void)var_scv_add(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00608   return var;
00609 } /* end ncap_var_scv_add() */

00645 {
00646   /* Purpose: Divide each element of var by value in scv */
00647   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00648 
00649   /* deal with inital scan */
00650   if(var->val.vp==NULL) return var; 
00651 
00652   (void)var_scv_dvd(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00653   return var;
00654 } /* end ncap_var_scv_dvd */

00629 {
00630   /* Purpose: Multiply variable by value in scv */
00631   if(var->undefined) return var;
00632   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00633 
00634   /* deal with inital scan */
00635   if(var->val.vp==NULL) 
00636     return var; 
00637 
00638 
00639   (void)var_scv_mlt(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00640   return var;
00641 } /* end ncap_var_scv_mlt */

00674 {
00675   /* Purpose: Modulus of each element of var with scv */
00676    if(var->undefined) return var;
00677 
00678 
00679   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00680   /* deal with inital scan */
00681   if(var->val.vp==NULL) return var; 
00682 
00683   (void)var_scv_mod(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00684   return var;
00685 } /* ncap_var_scv_mod */

00704 {
00705   /* Purpose: Empower each element in var by scv */
00706   /* Promote scv and var to NC_FLOAT if necessary since C has no integer empowerment 
00707      This reduces type conversion warnings (it is not done to avoid overflow) */
00708   if(var->type < NC_FLOAT) var=nco_var_cnf_typ((nc_type)NC_FLOAT,var);
00709   (void)nco_scv_cnf_typ(var->type,&scv);
00710 
00711   /* deal with inital scan */
00712   if(var->val.vp==NULL) return var; 
00713 
00714   (void)var_scv_pwr(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00715   return var;
00716 } /* end ncap_var_scv_pwr */

00613 {
00614   /* Purpose: Subtract value in scv from each element of var */
00615   if(var->undefined) return var;
00616 
00617   (void)ncap_var_scv_cnf_typ_hgh_prc(&var,&scv);
00618   /* deal with inital scan */
00619   if(var->val.vp==NULL) return var; 
00620 
00621   (void)ncap_scv_minus(&scv);
00622   (void)var_scv_add(var->type,var->sz,var->has_mss_val,var->mss_val,var->val,&scv);
00623   
00624   return var;
00625 } /* end ncap_var_scv_sub() */

00558 {
00559   /* Purpose: Make input variables conform or die
00560      var_1 and var_2 are considered completely symmetrically
00561      No assumption is made about var_1 relative to var_2
00562      Main difference betwee ncap_var_stretch() and nco_var_cnf_dmn() is
00563      If variables conform, then ncap_var_stretch() will broadcast
00564      If variables share no dimensions, then ncap_var_stretch() will convolve
00565      
00566      Terminology--- 
00567      Broadcast: Inflate smaller conforming variable to larger variable
00568      Conform: Dimensions of one variable are subset of other variable
00569      Convolve: Construct array whose rank is sum of non-duplicated dimensions
00570      Stretch: Union of broadcast and convolve
00571      
00572      Logic is pared down version of nco_var_cnf_dmn()
00573      1. USE_DUMMY_WGT has been eliminated: 
00574      ncap has no reason not to stretch input variables because grammar
00575      ensures only arithmetic variables will be stretched.
00576      
00577      2. wgt_crr has been eliminated:
00578      ncap never does anything multiple times so no equivalent to wgt_crr exists
00579      
00580      3. ncap_var_stretch(), unlike nco_var_cnf_dmn(), performs memory management
00581      Variables are var_free'd if they are superceded (replaced)
00582      
00583      4. Conformance logic is duplicated from nco_var_cnf_dmn()
00584      var_gtr plays role of var
00585      var_lsr plays role of wgt
00586      var_lsr_out plays role of wgt_out
00587      var_lsr_out=var_lsr only if variables already conform
00588      var_gtr_out is required since both variables may change
00589      var_gtr_out=var_gtr unless convolution is required */
00590   
00591   nco_bool CONFORMABLE=False; /* [flg] Whether var_lsr can be made to conform to var_gtr */
00592   nco_bool CONVOLVE=False; /* [flg] var_1 and var_2 had to be convolved */
00593   nco_bool DO_CONFORM; /* [flg] Did var_1 and var_2 conform? */
00594   nco_bool MUST_CONFORM=False; /* [flg] Must var_1 and var_2 conform? */
00595   
00596   int idx;
00597   int idx_dmn;
00598   int var_lsr_var_gtr_dmn_shr_nbr=0; /* [nbr] Number of dimensions shared by var_lsr and var_gtr */
00599   
00600   var_sct *var_gtr=NULL; /* [ptr] Pointer to variable structure of greater rank */
00601   var_sct *var_lsr=NULL; /* [ptr] Pointer to variable structure to lesser rank */
00602   var_sct *var_gtr_out=NULL; /* [ptr] Pointer to stretched version of greater rank variable */
00603   var_sct *var_lsr_out=NULL; /* [ptr] Pointer to stretched version of lesser rank variable */
00604   
00605   /* Initialize flag to false. Overwrite by true after successful conformance */
00606   DO_CONFORM=False;
00607   
00608   /* Determine which variable is greater and which lesser rank */
00609   if((*var_1)->nbr_dim >= (*var_2)->nbr_dim){
00610     var_gtr=*var_1;
00611     var_lsr=*var_2;
00612   }else{
00613     var_gtr=*var_2;
00614     var_lsr=*var_1;
00615   } /* endif */
00616   
00617   /* var_gtr_out=var_gtr unless convolution is required */
00618   var_gtr_out=var_gtr;
00619   
00620   /* Does lesser variable (var_lsr) conform to greater variable's dimensions? */
00621   if(var_lsr_out == NULL){
00622     if(var_gtr->nbr_dim > 0){
00623       /* Test that all dimensions in var_lsr appear in var_gtr */
00624       for(idx=0;idx<var_lsr->nbr_dim;idx++){
00625         for(idx_dmn=0;idx_dmn<var_gtr->nbr_dim;idx_dmn++){
00626           /* Compare names, not dimension IDs */
00627           if(!strcmp(var_lsr->dim[idx]->nm,var_gtr->dim[idx_dmn]->nm)){
00628             var_lsr_var_gtr_dmn_shr_nbr++; /* var_lsr and var_gtr share this dimension */
00629             break;
00630           } /* endif */
00631         } /* end loop over var_gtr dimensions */
00632       } /* end loop over var_lsr dimensions */
00633       /* Decide whether var_lsr and var_gtr dimensions conform, are mutually exclusive, or are partially exclusive */ 
00634       if(var_lsr_var_gtr_dmn_shr_nbr == var_lsr->nbr_dim){
00635         /* var_lsr and var_gtr conform */
00636         /* fxm: Variables do not conform when dimension list of one is subset of other if order of dimensions differs, i.e., a(lat,lev,lon) !~ b(lon,lev) */
00637         CONFORMABLE=True;
00638       }else if(var_lsr_var_gtr_dmn_shr_nbr == 0){
00639         /* Dimensions in var_lsr and var_gtr are mutually exclusive */
00640         CONFORMABLE=False;
00641         if(MUST_CONFORM){
00642           (void)fprintf(stdout,"%s: ERROR %s and template %s share no dimensions\n",prg_nm_get(),var_lsr->nm,var_gtr->nm);
00643           nco_exit(EXIT_FAILURE);
00644         }else{
00645           if(dbg_lvl_get() >= 1) (void)fprintf(stdout,"\n%s: DEBUG %s and %s share no dimensions: Attempting to convolve...\n",prg_nm_get(),var_lsr->nm,var_gtr->nm);
00646           CONVOLVE=True;
00647         } /* endif */
00648       }else if(var_lsr_var_gtr_dmn_shr_nbr > 0 && var_lsr_var_gtr_dmn_shr_nbr < var_lsr->nbr_dim){
00649         /* Some, but not all, of var_lsr dimensions are in var_gtr */
00650         CONFORMABLE=False;
00651         if(MUST_CONFORM){
00652           (void)fprintf(stdout,"%s: ERROR %d dimensions of %s belong to template %s but %d dimensions do not\n",prg_nm_get(),var_lsr_var_gtr_dmn_shr_nbr,var_lsr->nm,var_gtr->nm,var_lsr->nbr_dim-var_lsr_var_gtr_dmn_shr_nbr);
00653           nco_exit(EXIT_FAILURE);
00654         }else{
00655           if(dbg_lvl_get() >= 1) (void)fprintf(stdout,"\n%s: DEBUG %d dimensions of %s belong to template %s but %d dimensions do not: Not broadcasting %s to %s, could attempt stretching???\n",prg_nm_get(),var_lsr_var_gtr_dmn_shr_nbr,var_lsr->nm,var_gtr->nm,var_lsr->nbr_dim-var_lsr_var_gtr_dmn_shr_nbr,var_lsr->nm,var_gtr->nm);
00656           CONVOLVE=True;
00657         } /* endif */
00658       } /* end if */
00659       if(CONFORMABLE){
00660         if(var_gtr->nbr_dim == var_lsr->nbr_dim){
00661           /* var_gtr and var_lsr conform and are same rank */
00662           /* Test whether all var_lsr and var_gtr dimensions match in sequence */
00663           for(idx=0;idx<var_gtr->nbr_dim;idx++){
00664             if(strcmp(var_lsr->dim[idx]->nm,var_gtr->dim[idx]->nm)) break;
00665           } /* end loop over dimensions */
00666           /* If so, take shortcut and copy var_lsr to var_lsr_out */
00667           if(idx == var_gtr->nbr_dim) DO_CONFORM=True;
00668         }else{
00669           /* var_gtr and var_lsr conform but are not same rank, set flag to proceed to generic conform routine */
00670           DO_CONFORM=False;
00671         } /* end else */
00672       } /* endif CONFORMABLE */
00673     }else{ /* nbr_dmn == 0 */
00674       /* var_gtr is scalar, if var_lsr is also then set flag to copy var_lsr to var_lsr_out else proceed to generic conform routine */
00675       if(var_lsr->nbr_dim == 0) DO_CONFORM=True; else DO_CONFORM=False;
00676     } /* end else nbr_dmn == 0 */
00677     if(CONFORMABLE && DO_CONFORM){
00678       var_lsr_out=nco_var_dpl(var_lsr);
00679       (void)nco_xrf_var(var_lsr,var_lsr_out);
00680     } /* end if */
00681   } /* endif var_lsr_out == NULL */
00682   
00683   if(var_lsr_out == NULL && CONVOLVE){
00684     /* Convolve variables by returned stretched variables with minimum possible number of dimensions */
00685     int dmn_nbr; /* Number of dimensions in convolution */
00686     if(dbg_lvl_get() >= 1) (void)fprintf(stdout,"\n%s: WARNING Convolution not yet implemented, results of operation between %s and %s are unpredictable\n",prg_nm_get(),var_lsr->nm,var_gtr->nm);
00687     /* Dimensions in convolution are union of dimensions in variables */
00688     dmn_nbr=var_lsr->nbr_dim+var_gtr->nbr_dim-var_lsr_var_gtr_dmn_shr_nbr; /* Number of dimensions in convolution */
00689     dmn_nbr=dmn_nbr; /* CEWI: Avert compiler warning that variable is set but never used */
00690     /* fxm: these should go away soon */
00691     var_lsr_out=nco_var_dpl(var_lsr);
00692     var_gtr_out=nco_var_dpl(var_gtr);
00693 
00694     /* for(idx_dmn=0;idx_dmn<var_gtr->nbr_dim;idx_dmn++){;}
00695        if(var_lsr_var_gtr_dmn_shr_nbr == 0); else; */
00696     
00697     /* Free calling variables */
00698     var_lsr=nco_var_free(var_lsr);
00699     var_gtr=nco_var_free(var_gtr);
00700   } /* endif STRETCH */
00701   
00702   if(var_lsr_out == NULL){
00703     /* Expand lesser variable (var_lsr) to match size of greater variable */
00704     const char fnc_nm[]="ncap_var_stretch()"; /* [sng] Function name */
00705     char *var_lsr_cp;
00706     char *var_lsr_out_cp;
00707     
00708     int idx_var_lsr_var_gtr[NC_MAX_DIMS];
00709     int var_lsr_nbr_dim;
00710     int var_gtr_nbr_dmn_m1;
00711     
00712     long *var_gtr_cnt;
00713     long dmn_ss[NC_MAX_DIMS];
00714     long dmn_var_gtr_map[NC_MAX_DIMS];
00715     long dmn_var_lsr_map[NC_MAX_DIMS];
00716     long var_gtr_lmn;
00717     long var_lsr_lmn;
00718     long var_gtr_sz;
00719     
00720     size_t var_lsr_typ_sz;
00721     
00722     /* Copy main attributes of greater variable into lesser variable */
00723     var_lsr_out=nco_var_dpl(var_gtr);
00724     (void)nco_xrf_var(var_lsr,var_lsr_out);
00725     
00726     /* Modify elements of lesser variable array */
00727     var_lsr_out->nm=(char *)nco_free(var_lsr_out->nm);
00728     var_lsr_out->nm=(char *)strdup(var_lsr->nm);
00729     var_lsr_out->id=var_lsr->id;
00730     var_lsr_out->type=var_lsr->type;
00731     /* Added 20050323: 
00732        Not quite sure why, but var->val.vp may already have values here when LHS-casting
00733        Perform safety free to guard against memory leaks */
00734     var_lsr_out->val.vp=nco_free(var_lsr_out->val.vp);
00735     var_lsr_out->val.vp=(void *)nco_malloc_dbg(var_lsr_out->sz*nco_typ_lng(var_lsr_out->type),"Unable to malloc() value buffer in variable stretching",fnc_nm);
00736     var_lsr_cp=(char *)var_lsr->val.vp;
00737     var_lsr_out_cp=(char *)var_lsr_out->val.vp;
00738     var_lsr_typ_sz=nco_typ_lng(var_lsr_out->type);
00739     
00740     if(var_lsr_out->nbr_dim == 0){
00741       /* Variables are scalars, not arrays */
00742       (void)memcpy(var_lsr_out_cp,var_lsr_cp,var_lsr_typ_sz);
00743     }else if(var_lsr->nbr_dim == 0){
00744       /* Lesser-ranked input variable is scalar 
00745          Expansion in this degenerate case needs no index juggling (reverse-mapping)
00746          Code as special case to speed-up important applications of ncap
00747          for synthetic file creation */
00748       var_gtr_sz=var_gtr->sz;
00749       for(var_gtr_lmn=0;var_gtr_lmn<var_gtr_sz;var_gtr_lmn++){
00750         (void)memcpy(var_lsr_out_cp+var_gtr_lmn*var_lsr_typ_sz,var_lsr_cp,var_lsr_typ_sz);
00751       } /* end loop over var_gtr_lmn */
00752     }else{
00753       /* Variables are arrays, not scalars */
00754       
00755       /* Create forward and reverse mappings from greater variable's dimensions to lesser variable's dimensions:
00756          
00757       dmn_var_gtr_map[i] is number of elements between one value of i_th 
00758       dimension of greater variable and next value of i_th dimension, i.e., 
00759       number of elements in memory between indicial increments in i_th dimension. 
00760       This is computed as product of one (1) times size of all dimensions (if any) after i_th 
00761       dimension in greater variable.
00762       
00763       dmn_var_lsr_map[i] contains analogous information, except for lesser variable
00764       
00765       idx_var_lsr_var_gtr[i] contains index into greater variable's dimensions of i_th dimension of lesser variable
00766       idx_var_gtr_var_lsr[i] contains index into lesser variable's dimensions of i_th dimension of greater variable 
00767       
00768       Since lesser variable is a subset of greater variable, some elements of idx_var_gtr_var_lsr may be "empty", or unused
00769       
00770       Since mapping arrays (dmn_var_gtr_map and dmn_var_lsr_map) are ultimately used for a
00771       memcpy() operation, they could (read: should) be computed as byte offsets, not type offsets.
00772       This is why netCDF generic hyperslab routines (ncvarputg(), ncvargetg())
00773       request imap vector to specify offset (imap) vector in bytes. */
00774       for(idx=0;idx<var_lsr->nbr_dim;idx++){
00775         for(idx_dmn=0;idx_dmn<var_gtr->nbr_dim;idx_dmn++){
00776           /* Compare names, not dimension IDs */
00777           if(!strcmp(var_gtr->dim[idx_dmn]->nm,var_lsr->dim[idx]->nm)){
00778             idx_var_lsr_var_gtr[idx]=idx_dmn;
00779             /*      idx_var_gtr_var_lsr[idx_dmn]=idx;*/
00780             break;
00781           } /* end if */
00782           /* Sanity check */
00783           if(idx_dmn == var_gtr->nbr_dim-1){
00784             (void)fprintf(stdout,"%s: ERROR var_lsr %s has dimension %s but var_gtr %s does not deep in ncap_var_stretch()\n",prg_nm_get(),var_lsr->nm,var_lsr->dim[idx]->nm,var_gtr->nm);
00785             nco_exit(EXIT_FAILURE);
00786           } /* end if err */
00787         } /* end loop over greater variable dimensions */
00788       } /* end loop over lesser variable dimensions */
00789       
00790       /* Figure out map for each dimension of greater variable */
00791       for(idx=0;idx<var_gtr->nbr_dim;idx++) dmn_var_gtr_map[idx]=1L;
00792       for(idx=0;idx<var_gtr->nbr_dim-1;idx++)
00793         for(idx_dmn=idx+1;idx_dmn<var_gtr->nbr_dim;idx_dmn++)
00794           dmn_var_gtr_map[idx]*=var_gtr->cnt[idx_dmn];
00795       
00796       /* Figure out map for each dimension of lesser variable */
00797       for(idx=0;idx<var_lsr->nbr_dim;idx++) dmn_var_lsr_map[idx]=1L;
00798       for(idx=0;idx<var_lsr->nbr_dim-1;idx++)
00799         for(idx_dmn=idx+1;idx_dmn<var_lsr->nbr_dim;idx_dmn++)
00800           dmn_var_lsr_map[idx]*=var_lsr->cnt[idx_dmn];
00801       
00802       /* Define convenience variables to avoid repetitive indirect addressing */
00803       var_lsr_nbr_dim=var_lsr->nbr_dim;
00804       var_gtr_sz=var_gtr->sz;
00805       var_gtr_cnt=var_gtr->cnt;
00806       var_gtr_nbr_dmn_m1=var_gtr->nbr_dim-1;
00807       
00808       /* var_gtr_lmn is offset into 1-D array corresponding to N-D indices dmn_ss */
00809       for(var_gtr_lmn=0;var_gtr_lmn<var_gtr_sz;var_gtr_lmn++){
00810         dmn_ss[var_gtr_nbr_dmn_m1]=var_gtr_lmn%var_gtr_cnt[var_gtr_nbr_dmn_m1];
00811         for(idx=0;idx<var_gtr_nbr_dmn_m1;idx++){
00812           dmn_ss[idx]=(long)(var_gtr_lmn/dmn_var_gtr_map[idx]);
00813           dmn_ss[idx]%=var_gtr_cnt[idx];
00814         } /* end loop over dimensions */
00815         
00816         /* Map (shared) N-D array indices into 1-D index into original lesser variable data */
00817         var_lsr_lmn=0L;
00818         for(idx=0;idx<var_lsr_nbr_dim;idx++) var_lsr_lmn+=dmn_ss[idx_var_lsr_var_gtr[idx]]*dmn_var_lsr_map[idx];
00819         
00820         (void)memcpy(var_lsr_out_cp+var_gtr_lmn*var_lsr_typ_sz,var_lsr_cp+var_lsr_lmn*var_lsr_typ_sz,var_lsr_typ_sz);
00821         
00822       } /* end loop over var_gtr_lmn */
00823       
00824     } /* end if greater variable (and lesser variable) are arrays, not scalars */
00825     
00826     DO_CONFORM=True;
00827   } /* end if we had to broadcast lesser variable to fit greater variable */
00828   
00829   /* Place variables in original order
00830      Not necessary if variables are used in binary operations that are associative
00831      But do not want to require that assumption of calling routines */
00832   if((*var_1)->nbr_dim >= (*var_2)->nbr_dim){
00833     *var_1=var_gtr_out; /* [ptr] First variable */
00834     *var_2=var_lsr_out; /* [ptr] Second variable */
00835   }else{
00836     *var_1=var_lsr_out; /* [ptr] First variable */
00837     *var_2=var_gtr_out; /* [ptr] Second variable */
00838   } /* endif */
00839   
00840   /* Variables now conform */
00841   return DO_CONFORM;
00842 } /* end ncap_var_stretch() */

00308 {
00309   /* Purpose: Add two variables */
00310   /* Store result in var_2 */
00311   if(var_1->undefined) var_2->undefined=True;
00312     if(var_2->undefined) {
00313     var_1=nco_var_free(var_1);
00314     return var_2;
00315   }
00316   (void)ncap_var_retype(var_1,var_2);
00317    
00318   /* Handle initial scan */
00319   if(var_1->val.vp==(void*)NULL ) {
00320     if(var_1->nbr_dim > var_2->nbr_dim) {
00321       var_2=nco_var_free(var_2);
00322       return var_1;
00323     }else{
00324       var_1=nco_var_free(var_1);
00325       return var_2;
00326     }
00327   } 
00328 
00329   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00330   
00331   //  if(var_1 != var_chk1) var_chk1 = (var_sct*)nco_var_free(var_chk1);
00332   //if(var_2 != var_chk2) var_chk2 = (var_sct*)nco_var_free(var_chk2);
00333 
00334   /* fxm: bug in nco_var_add()? missing_value is not carried over to var_2 in result when var_1->has_mss_val is true */
00335   if(var_1->has_mss_val){
00336     (void)nco_var_add(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00337   }else{
00338     (void)nco_var_add(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00339   } /* end if */
00340 
00341   var_1=nco_var_free(var_1);
00342   return var_2;
00343 } /* end ncap_var_var_add() */

00349 {
00350   /* Purpose: Divide two variables (var_2/var_1) */
00351 
00352   /* Purpose: Divide two variables */
00353   /* Store result in var_2 */
00354   if(var_1->undefined) var_2->undefined=True;
00355     if(var_2->undefined) {
00356     var_1=nco_var_free(var_1);
00357     return var_2;
00358   }
00359   (void)ncap_var_retype(var_1,var_2);
00360    
00361   /* Handle initial scan */
00362   if(var_1->val.vp==(void*)NULL ) {
00363     if(var_1->nbr_dim > var_2->nbr_dim) {
00364       var_2=nco_var_free(var_2);
00365       return var_1;
00366     }else{
00367       var_1=nco_var_free(var_1);
00368       return var_2;
00369     }
00370   } 
00371    
00372 
00373   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00374   if(var_1->has_mss_val){
00375     (void)nco_var_dvd(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00376   }else{
00377     (void)nco_var_dvd(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00378   } /* end else */
00379 
00380   var_1=nco_var_free(var_1);
00381   return var_2;
00382 } /* end ncap_var_var_dvd() */

00388 {
00389 
00390   /* Purpose: Multiply two variables */
00391   /* Store result in var_2 */
00392   if(var_1->undefined) var_2->undefined=True;
00393     if(var_2->undefined) {
00394     var_1=nco_var_free(var_1);
00395     return var_2;
00396   }
00397   (void)ncap_var_retype(var_1,var_2);
00398    
00399   /* Handle initial scan */
00400   if(var_1->val.vp==(void*)NULL ) {
00401     if(var_1->nbr_dim > var_2->nbr_dim) {
00402       var_2=nco_var_free(var_2);
00403       return var_1;
00404     }else{
00405       var_1=nco_var_free(var_1);
00406       return var_2;
00407     }
00408   } 
00409 
00410   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00411   if(var_1->has_mss_val){
00412     (void)nco_var_mlt(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00413   }else{
00414     (void)nco_var_mlt(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00415   } /* end else */
00416 
00417   var_1=nco_var_free(var_1);
00418    return var_2;
00419 } /* end ncap_var_var_mlt() */

00252 {
00253   /* Purpose: Remainder (modulo) operation of two variables (var_1%var_2) */
00254   /* Store result in var_2 */
00255   if(var_1->undefined) var_2->undefined=True;
00256     if(var_2->undefined) {
00257     var_1=nco_var_free(var_1);
00258     return var_2;
00259   }
00260   (void)ncap_var_retype(var_1,var_2);
00261    
00262   /* Handle initial scan */
00263   if(var_1->val.vp==(void*)NULL ) {
00264     if(var_1->nbr_dim > var_2->nbr_dim) {
00265       var_2=nco_var_free(var_2);
00266       return var_1;
00267     }else{
00268       var_1=nco_var_free(var_1);
00269       return var_2;
00270     }
00271   } 
00272 
00273 
00274  
00275   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00276   if(var_1->has_mss_val){
00277     (void)nco_var_mod(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00278   }else{
00279     (void)nco_var_mod(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00280   } /* end else */
00281    
00282    var_1=nco_var_free(var_1);
00283    return var_2;
00284 } /* end ncap_var_var_mod() */

00290 {
00291   /* Purpose: Empower two variables (var_1^var_2) */
00292 
00293   if(var_1->undefined) var_2->undefined=True;
00294     if(var_2->undefined) {
00295     var_1=nco_var_free(var_1);
00296     return var_2;
00297   }
00298   /* make sure vars are at least float */
00299 
00300   (void)ncap_var_retype(var_1,var_2);   
00301 
00302   /* Handle initial scan */
00303   if(var_1->val.vp==(void*)NULL ) {
00304     if(var_1->nbr_dim > var_2->nbr_dim) {
00305       var_2=nco_var_free(var_2);
00306       return var_1;
00307     }else{
00308       var_1=nco_var_free(var_1);
00309       return var_2;
00310     }
00311   } 
00312 
00313   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00314   if(var_1->has_mss_val){
00315     (void)nco_var_pwr(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00316   }else{
00317     (void)nco_var_pwr(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00318   } /* end else */
00319    return var_2;
00320 } /* end ncap_var_var_pwr() */

00504                                                                                        : 19 non-standard argument order */
00505  var_sct *var_1) /* I [sct] Variable structure containing first operand */
00506 {
00507   /* Purpose: Subtract a variable from another variable */
00508 
00509   /* Purpose: Add two variables */
00510   /* Store result in var_2 */
00511   if(var_1->undefined) var_2->undefined=True;
00512     if(var_2->undefined) {
00513     var_1=nco_var_free(var_1);
00514     return var_2;
00515   }
00516   (void)ncap_var_retype(var_1,var_2);
00517    
00518   /* Handle initial scan */
00519   if(var_1->val.vp==(void*)NULL ) {
00520     if(var_1->nbr_dim > var_2->nbr_dim) {
00521       var_2=nco_var_free(var_2);
00522       return var_1;
00523     }else{
00524       var_1=nco_var_free(var_1);
00525       return var_2;
00526     }
00527   } 
00528 
00529   (void)ncap_var_cnf_dmn(&var_1,&var_2);
00530   if(var_1->has_mss_val){
00531     (void)nco_var_sbt(var_1->type,var_1->sz,var_1->has_mss_val,var_1->mss_val,var_1->val,var_2->val);
00532   }else{
00533     (void)nco_var_sbt(var_1->type,var_1->sz,var_2->has_mss_val,var_2->mss_val,var_1->val,var_2->val);
00534   }/* end else */
00535   var_1=nco_var_free(var_1);
00536   return var_2;
00537 } /* end ncap_var_var_sub() */

00117 {
00118 
00119   /* Purpose: Define variable in output file and write variable */
00120   const char mss_val_sng[]="missing_value"; /* [sng] Unidata standard string for missing value */
00121   const char add_fst_sng[]="add_offset"; /* [sng] Unidata standard string for add offset */
00122   const char scl_fct_sng[]="scale_factor"; /* [sng] Unidata standard string for scale factor */
00123   int rcd; /* [rcd] Return code */
00124   int var_out_id;
00125 
00126 #ifdef NCO_RUSAGE_DBG
00127   long maxrss; /* [B] Maximum resident set size */
00128 #endif /* !NCO_RUSAGE_DBG */
00129 
00130 
00131   rcd=nco_inq_varid_flg(prs_arg->out_id,var->nm,&var_out_id);
00132 
00133   if(rcd == NC_NOERR){
00134     (void)fprintf(stdout,"Warning: Variable %s has aleady been saved in %s",var->nm,prs_arg->fl_out);
00135     var = nco_var_free(var);
00136     return False;
00137   }
00138   
00139   /* Put file in define mode to allow metadata writing */
00140   (void)nco_redef(prs_arg->out_id);
00141   
00142   /* Define variable */   
00143   (void)nco_def_var(prs_arg->out_id,var->nm,var->type,var->nbr_dim,var->dmn_id,&var_out_id);
00144   /* Put missing value */  
00145   if(var->has_mss_val) (void)nco_put_att(prs_arg->out_id,var_out_id,mss_val_sng,var->type,1,var->mss_val.vp);
00146   
00147       /* Write/overwrite scale_factor and add_offset attributes */
00148   if(var->pck_ram){ /* Variable is packed in memory */
00149   if(var->has_scl_fct) (void)nco_put_att(prs_arg->out_id,var_out_id,scl_fct_sng,var->typ_upk,1,var->scl_fct.vp);
00150   if(var->has_add_fst) (void)nco_put_att(prs_arg->out_id,var_out_id,add_fst_sng,var->typ_upk,1,var->add_fst.vp);
00151       } /* endif pck_ram */
00152 
00153   /* Take output file out of define mode */
00154   (void)nco_enddef(prs_arg->out_id);
00155   
00156   /* Write variable */ 
00157   if(var->nbr_dim == 0){
00158     (void)nco_put_var1(prs_arg->out_id,var_out_id,0L,var->val.vp,var->type);
00159   }else{
00160     (void)nco_put_vara(prs_arg->out_id,var_out_id,var->srt,var->cnt,var->val.vp,var->type);
00161   } /* end else */
00162   
00163 #ifdef NCO_RUSAGE_DBG
00164   /* Compile: cd ~/nco/bld;make 'USR_TKN=-DNCO_RUSAGE_DBG';cd - */
00165   /* Print rusage memory usage statistics */
00166   if(dbg_lvl_get() >= 0) (void)fprintf(stdout,"%s: INFO ncap_var_write() writing variable %s\n",prg_nm_get(),var->nm);
00167   maxrss=nco_mmr_rusage_prn((int)0);
00168 #endif /* !NCO_RUSAGE_DBG */
00169 
00170   /* Free varible */
00171   var=nco_var_free(var);
00172 
00173   return True;
00174 } /* end ncap_var_write() */

01056 {
01057   int idx;
01058   int jdx;
01059   int rcd;
01060   int var_id;
01061   int size=0;
01062   nm_id_sct *xtr_lst=NULL;  
01063   for(idx=0;idx<nbr_att;idx++){
01064     rcd=nco_inq_varid_flg(out_id,att_lst[idx]->var_nm,&var_id);
01065     if(rcd== NC_NOERR) continue;   
01066     rcd=nco_inq_varid_flg(in_id,att_lst[idx]->var_nm,&var_id);   
01067     if(rcd == NC_NOERR){
01068       /* eliminate any duplicates from list */
01069       for(jdx=0;jdx<size;jdx++)
01070         if(!strcmp(xtr_lst[jdx].nm,att_lst[idx]->var_nm)) break;
01071       if(jdx!=size) continue;
01072       /* fxm mmr TODO 491: memory leak xtr_lst */
01073       xtr_lst=(nm_id_sct *)nco_realloc(xtr_lst,(size+1)*sizeof(nm_id_sct));
01074       xtr_lst[size].id=var_id;
01075       xtr_lst[size++].nm=(char *)strdup(att_lst[idx]->var_nm);
01076     } /* end if */
01077   } /* end loop over att */
01078   
01079   *nbr_lst=size;
01080   
01081   return xtr_lst;
01082 } /* end nco_att_lst_mk() */

00495 {
00496   int idx;
00497   int nbr_dmn_in;
00498   char dmn_nm[NC_MAX_NAME];
00499   nm_id_sct *dmn;
00500   /* Get number of dimensions */
00501   (void)nco_inq(nc_id,&nbr_dmn_in,(int *)NULL,(int *)NULL,(int *)NULL);
00502   
00503   dmn=(nm_id_sct *)nco_malloc(nbr_dmn_in*sizeof(nm_id_sct));
00504   
00505   for(idx=0;idx<nbr_dmn_in;idx++){
00506     (void)nco_inq_dimname(nc_id,idx,dmn_nm);
00507     dmn[idx].id=idx;
00508     dmn[idx].nm=(char *)strdup(dmn_nm);
00509   } /* end loop over dmn */
00510   
00511   *nbr_dmn=nbr_dmn_in;
00512   return dmn;
00513 } /* end nco_dmn_lst() */

00143 {
00144   /* Purpose: Expand dimension list by one and return pointer to newly created member */
00145 
00146   int *sz;
00147   sz=prs_arg->nbr_dmn_out;
00148   
00149   *(prs_arg->dmn_out)=(dmn_sct **)nco_realloc(*(prs_arg->dmn_out),(++*sz)*sizeof(dmn_sct *));
00150   
00151   return (*(prs_arg->dmn_out)+(*sz-1));
00152 } /* end nco_dmn_out_grow() */

00194 {
00195   /* Purpose: Print netCDF library version */
00196 
00197   char *cmp_dat_sng;
00198   char *dlr_ptr;
00199   char *lbr_sng;
00200   char *lbr_vrs_sng;
00201   char *of_ptr;
00202 
00203   size_t cmp_dat_sng_lng;
00204   size_t lbr_vrs_sng_lng;
00205 
00206   /* Behavior of nc_inq_libvers() depends on library versions. Return values are:
00207      netCDF 3.4--3.6.x: "3.4 of May 16 1998 14:06:16 $"
00208      netCDF 4.0-alpha1-4.0-alpha10: NULL
00209      netCDF 4.0-alpha11-present: "4.0-alpha11" */  
00210   lbr_sng=(char *)strdup(nc_inq_libvers());
00211   /* (void)fprintf(stderr,"%s: nco_lbr_vrs_prn() returns %s\n",prg_nm_get(),lbr_sng);*/
00212   of_ptr=strstr(lbr_sng," of ");
00213   if(of_ptr == NULL){
00214     (void)fprintf(stderr,"%s: WARNING nco_lbr_vrs_prn() reports of_ptr == NULL\n",prg_nm_get());
00215     lbr_vrs_sng_lng=(size_t)strlen(lbr_sng);
00216   }else{
00217     lbr_vrs_sng_lng=(size_t)(of_ptr-lbr_sng);
00218   } /* endif */
00219   lbr_vrs_sng=(char *)nco_malloc(lbr_vrs_sng_lng+1);
00220   strncpy(lbr_vrs_sng,lbr_sng,lbr_vrs_sng_lng);
00221   lbr_vrs_sng[lbr_vrs_sng_lng]='\0'; /* NUL-terminate */
00222 
00223   dlr_ptr=strstr(lbr_sng," $");
00224   if(of_ptr != NULL && dlr_ptr != NULL){
00225     cmp_dat_sng_lng=(size_t)(dlr_ptr-of_ptr-4); /* 4 is the length of " of " */
00226     cmp_dat_sng=(char *)nco_malloc(cmp_dat_sng_lng+1ul);
00227     strncpy(cmp_dat_sng,of_ptr+4,cmp_dat_sng_lng); /* 4 is the length of " of " */
00228     cmp_dat_sng[cmp_dat_sng_lng]='\0'; /* NUL-terminate */
00229   }else{
00230     cmp_dat_sng=(char *)strdup("Unknown");
00231   } /* endif */
00232 
00233   (void)fprintf(stderr,"Linked to netCDF library version %s, compiled %s\n",lbr_vrs_sng,cmp_dat_sng);
00234   (void)fprintf(stdout,"Homepage URL: http://nco.sf.net\n");
00235   (void)fprintf(stdout,"User's Guide: http://nco.sf.net/nco.html\n");
00236   /* fxm: TKN2YESNO breaks when TKN is undefined
00237      Full macro language like M4 might be useful here, though probably too much trouble */
00238 #define TKN2YESNO(x) ((x+0) ? ("No"):("Yes"))
00239   /* Configuration option tokens must be consistent among configure.in, bld/Makefile, and nco_ctl.c
00240      Arrange tokens alphabetically by first word in English text description */
00241   (void)fprintf(stderr,"Configuration Option:\tActive?\tMeaning or Reference:\nDebugging: Custom\t%s\tPedantic, bounds checking (slowest execution)\nDebugging: Symbols\t%s\tProduce symbols for debuggers (e.g., dbx, gdb)\nInternationalization\t%s\thttp://nco.sf.net/nco.html#i18n (pre-alpha)\nMPI parallelization\t%s\thttp://nco.sf.net/nco.html#mpi (alpha)\nnetCDF3 64-bit files\t%s\thttp://nco.sf.net/nco.html#lfs\nnetCDF4/HDF\t\t%s\thttp://nco.sf.net/nco.html#netcdf4\nOPeNDAP/DODS clients\t%s\thttp://nco.sf.net/nco.html#dap\nOpenMP SMP threading\t%s\thttp://nco.sf.net/nco.html#omp\nOptimization: run-time\t%s\tFastest execution possible (slowest compilation)\nParallel netCDF3\t%s\thttp://nco.sf.net/nco.html#pnetcdf (pre-alpha)\nShared libraries built\t%s\tSmall, dynamically linked executables\nStatic libraries built\t%s\tLarge executables with private namespaces\nUDUnits conversions\t%s\thttp://nco.sf.net/nco.html#udunits\nWildcarding (regex)\t%s\thttp://nco.sf.net/nco.html#rx\n%s",
00242 #if defined(ENABLE_DEBUG_CUSTOM) && (ENABLE_DEBUG_CUSTOM)
00243                 "Yes",
00244 #else /* !ENABLE_DEBUG_CUSTOM */
00245                 "No",
00246 #endif /* !ENABLE_DEBUG_CUSTOM */
00247 #if defined(ENABLE_DEBUG_SYMBOLS) && (ENABLE_DEBUG_SYMBOLS)
00248                 "Yes",
00249 #else /* !ENABLE_DEBUG_SYMBOLS */
00250                 "No",
00251 #endif /* !ENABLE_DEBUG_SYMBOLS */
00252 #if defined(I18N) && (I18N)
00253                 "Yes",
00254 #else /* !I18N */
00255                 "No",
00256 #endif /* !I18N */
00257 #if defined(ENABLE_MPI) && (ENABLE_MPI)
00258                 "Yes",
00259 #else /* !ENABLE_MPI */
00260                 "No",
00261 #endif /* !ENABLE_MPI */
00262 #if defined(NC_64BIT_OFFSET) && (NC_64BIT_OFFSET)
00263                 "Yes",
00264 #else /* !NC_64BIT_OFFSET */
00265                 "No",
00266 #endif /* !NC_64BIT_OFFSET */
00267 #if defined(ENABLE_NETCDF4) && (ENABLE_NETCDF4)
00268                 "Yes",
00269 #else /* !ENABLE_NETCDF4 */
00270                 "No",
00271 #endif /* !ENABLE_NETCDF4 */
00272 #if defined(ENABLE_DAP) && (ENABLE_DAP)
00273                 "Yes",
00274 #else /* !ENABLE_DAP */
00275                 "No",
00276 #endif /* !ENABLE_DAP */
00277 #if defined(_OPENMP) && (_OPENMP)
00278                 "Yes",
00279 #else /* !_OPENMP */
00280                 "No",
00281 #endif /* !_OPENMP */
00282 #if defined(ENABLE_OPTIMIZE_CUSTOM) && (ENABLE_OPTIMIZE_CUSTOM)
00283                 "Yes",
00284 #else /* !ENABLE_OPTIMIZE_CUSTOM */
00285                 "No",
00286 #endif /* !ENABLE_OPTIMIZE_CUSTOM */
00287 #if defined(ENABLE_PNETCDF) && (ENABLE_PNETCDF)
00288                 "Yes",
00289 #else /* !ENABLE_PNETCDF */
00290                 "No",
00291 #endif /* !ENABLE_PNETCDF */
00292 #if defined(ENABLE_SHARED) && (ENABLE_SHARED)
00293                 "Yes",
00294 #else /* !ENABLE_SHARED */
00295                 "No",
00296 #endif /* !ENABLE_SHARED */
00297 #if defined(ENABLE_STATIC) && (ENABLE_STATIC)
00298                 "Yes",
00299 #else /* !ENABLE_STATIC */
00300                 "No",
00301 #endif /* !ENABLE_STATIC */
00302 #if defined(ENABLE_UDUNITS) && (ENABLE_UDUNITS)
00303                 "Yes",
00304 #else /* !ENABLE_UDUNITS */
00305                 "No",
00306 #endif /* !ENABLE_UDUNITS */
00307 #if defined(NCO_HAVE_REGEX_FUNCTIONALITY) && (NCO_HAVE_REGEX_FUNCTIONALITY)
00308                 "Yes",
00309 #else /* !NCO_HAVE_REGEX_FUNCTIONALITY */
00310                 "No",
00311 #endif /* !NCO_HAVE_REGEX_FUNCTIONALITY */
00312                 ""); /* End of print statement marker */
00313   (void)fprintf(stderr,"\n%s",nco_nmn_get());
00314 
00315   lbr_vrs_sng=(char *)nco_free(lbr_vrs_sng);
00316   lbr_sng=(char *)nco_free(lbr_sng);
00317   cmp_dat_sng=(char *)nco_free(cmp_dat_sng);
00318 } /* end nco_lbr_vrs_prn() */

00982                  : I netCDF file ID
00983         nm_id_sct *xtr_lst: I/O current extraction list 
00984         int *nbr_xtr: I/O number of variables in current extraction list: Overwritten by new list 
00985         nm_id_sct nco_nm_id_lst_crd_make: list of coordinate dimensions 
00986      */
00987 {
00988   /* Purpose: Make list co-ordinate dimensions from list of ordinary and co-ordinate variables */
00989   char dmn_nm[NC_MAX_NAME];
00990   
00991   int crd_id;
00992   int idx_dim;
00993   int idx_var;
00994   int nbr_dim;
00995   int rcd=NC_NOERR; /* [rcd] Return code */
00996   int nbr_new_lst=0;
00997   
00998   nm_id_sct *new_lst=NULL_CEWI;
00999   
01000   /* Get number of dimensions */
01001   (void)nco_inq(nc_id,&nbr_dim,(int *)NULL,(int *)NULL,(int *)NULL);
01002   /* ...for each dimension in input file... */
01003   for(idx_dim=0;idx_dim<nbr_dim;idx_dim++){
01004     /* ...see if it is a coordinate dimension... */
01005     (void)nco_inq_dimname(nc_id,idx_dim,dmn_nm);
01006     rcd=nco_inq_varid_flg(nc_id,dmn_nm,&crd_id);
01007     if(rcd == NC_NOERR){
01008       /* Is this coordinate already on extraction list? */
01009       for(idx_var=0;idx_var<*nbr_xtr;idx_var++){
01010         if(!strcmp(dmn_nm,xtr_lst[idx_var].nm)){
01011           if(nbr_new_lst == 0) new_lst=(nm_id_sct *)nco_malloc(sizeof(nm_id_sct));
01012           else new_lst=(nm_id_sct *)nco_realloc((void *)new_lst,(size_t)(nbr_new_lst+1)*sizeof(nm_id_sct));
01013           new_lst[nbr_new_lst].nm=(char *)strdup(dmn_nm);
01014           new_lst[nbr_new_lst++].id=crd_id;
01015           break;
01016         } /* end if */
01017       } /* end for */
01018     } /* end if */
01019   } /* end for */
01020   
01021   *nbr_xtr=nbr_new_lst;
01022   return new_lst;
01023 } /* end nco_nm_id_lst_crd_make() */

00455 {
00456   /* Purpose: Add to xtr_lst any elements from xtr_lst_a not already present and return new list */
00457   int idx;
00458   int xtr_idx;
00459   int nbr_xtr_crr;
00460   
00461   nm_id_sct *xtr_new_lst;
00462   
00463   nco_bool match;
00464   
00465   nbr_xtr_crr=*nbr_xtr;
00466   if(nbr_xtr_crr > 0){
00467     xtr_new_lst=(nm_id_sct*)nco_malloc((size_t)(*nbr_xtr)*sizeof(nm_id_sct));
00468     for(idx=0;idx<nbr_xtr_crr;idx++){
00469       xtr_new_lst[idx].nm=(char *)strdup(xtr_lst[idx].nm);
00470       xtr_new_lst[idx].id=xtr_lst[idx].id;
00471     } /* end loop over variables */
00472   }else{
00473     *nbr_xtr=nbr_lst_a;
00474     return nco_var_lst_copy(xtr_lst_a,nbr_lst_a);
00475   }/* end if */
00476   
00477   for(idx=0;idx<nbr_lst_a;idx++){
00478     match=False;
00479     for(xtr_idx=0;xtr_idx<*nbr_xtr;xtr_idx++)
00480       if(!strcmp(xtr_lst[xtr_idx].nm,xtr_lst_a[idx].nm)){match=True;break;}
00481     if(match) continue;
00482     xtr_new_lst=(nm_id_sct *)nco_realloc(xtr_new_lst,(size_t)(nbr_xtr_crr+1)*sizeof(nm_id_sct));
00483     xtr_new_lst[nbr_xtr_crr].nm=(char *)strdup(xtr_lst_a[idx].nm);
00484     xtr_new_lst[nbr_xtr_crr++].id=xtr_lst_a[idx].id;
00485   } /* end for */
00486   *nbr_xtr=nbr_xtr_crr;
00487   return xtr_new_lst;           
00488 } /* end nco_var_lst_add */

00396                                          : Copy xtr_lst and return new list */
00397 nm_id_sct *xtr_lst,    /* I  [sct] input list */ 
00398 int lst_nbr)           /* I  [nbr] number of elements in list */
00399 {
00400   int idx;
00401   nm_id_sct *xtr_new_lst;
00402   
00403   if(lst_nbr == 0) return NULL;
00404   xtr_new_lst=(nm_id_sct *)nco_malloc(lst_nbr*sizeof(nm_id_sct));
00405   for(idx=0;idx<lst_nbr;idx++){
00406     xtr_new_lst[idx].nm=(char *)strdup(xtr_lst[idx].nm);
00407     xtr_new_lst[idx].id=xtr_lst[idx].id;
00408   } /* end loop over variable */
00409   return xtr_new_lst;           
00410 } /* end nco_var_lst_copy() */

00419 {
00420   /* Purpose: Subtract from xtr_lst any elements from xtr_lst_b which are present and return new list */
00421   int idx;
00422   int xtr_idx;
00423   int xtr_nbr_new=0;
00424   
00425   nco_bool match;
00426   
00427   nm_id_sct *xtr_new_lst=NULL;
00428   
00429   if(*nbr_xtr == 0) return xtr_lst;
00430   
00431   xtr_new_lst=(nm_id_sct*)nco_malloc((size_t)(*nbr_xtr)*sizeof(nm_id_sct)); 
00432   for(idx=0;idx<*nbr_xtr;idx++){
00433     match=False;
00434     for(xtr_idx=0;xtr_idx<nbr_lst_b;xtr_idx++)
00435       if(!strcmp(xtr_lst[idx].nm,xtr_lst_b[xtr_idx].nm)){match=True;break;}
00436     if(match) continue;
00437     xtr_new_lst[xtr_nbr_new].nm=(char *)strdup(xtr_lst[idx].nm);
00438     xtr_new_lst[xtr_nbr_new++].id=xtr_lst[idx].id;
00439   } /* end loop over idx */
00440   /* realloc to actual size */
00441   xtr_new_lst=(nm_id_sct*)nco_realloc(xtr_new_lst,xtr_nbr_new*sizeof(nm_id_sct)); 
00442   /* free old list */
00443   xtr_lst=nco_nm_id_lst_free(xtr_lst,*nbr_xtr);
00444 
00445   *nbr_xtr=xtr_nbr_new;
00446   return xtr_new_lst;     
00447 }/* end nco_var_lst_sub */


Classes
struct	sym_sct
struct	opr_nod_sct
union	nod_typ_tag
struct	nm_lst_sct
struct	prs_sct
Typedefs
typedef nod_typ_tag	nodeType
Functions
void	ncap_ntl_scn (prs_sct const prs_arg, const char const spt_arg_cat, nm_id_sct *const xtr_lst_a, int const nbr_lst_a, nm_id_sct *const xtr_lst_b, int const nbr_lst_b, nm_id_sct *const xtr_lst_c, int const nbr_lst_c, nm_id_sct *const xtr_lst_d, int const nbr_lst_d)
int	ncap_ncwa_scn (prs_sct const prs_arg, const char const msk_sng, char *msk_nm, double msk_val, int *op_typ_rlt)
void	freeNode (nodeType *nod)
aed_sct *	ncap_aed_lookup (const char const var_nm, const char const att_nm, prs_sct *const prs_arg, const bool update)
var_sct *	ncap_var_lookup (var_sct var, prs_sct prs_arg, const bool add)
void	nco_var_free_wrp (var_sct **)
nodeType *	opr_ctl (int opr_tkn, int arg_nbr,...)
int	yyerror (prs_sct prs_arg, const char const sng)
var_sct *	ncap_var_var_add (var_sct var_1, var_sct var_2)
var_sct *	ncap_var_var_dvd (var_sct var_1, var_sct var_2)
var_sct *	ncap_var_var_mlt (var_sct var_1, var_sct var_2)
var_sct *	ncap_var_var_mod (var_sct var_1, var_sct var_2)
var_sct *	ncap_var_var_pwr (var_sct var_1, var_sct var_2)
var_sct *	ncap_var_var_sub (var_sct var_2, var_sct var_1)
bool	ncap_var_stretch (var_sct , var_sct )
dmn_sct **	nco_dmn_out_grow (prs_sct *)
int	ncap_scv_minus (scv_sct *)
int	ncap_var_write (var_sct , prs_sct )
nm_id_sct *	nco_nm_id_lst_crd_make (int, nm_id_sct , int )
nm_id_sct *	nco_var_lst_add (nm_id_sct , int , nm_id_sct *, int)
nm_id_sct *	nco_var_lst_copy (nm_id_sct *, int)
nm_id_sct *	nco_var_lst_sub (nm_id_sct , int , nm_id_sct *, int)
nm_id_sct *	nco_dmn_lst (const int, int *const)
nm_id_sct *	nco_att_lst_mk (int, int, aed_sct *, int, int )
ptr_unn	ncap_scv_2_ptr_unn (scv_sct)
scv_sct	ncap_scv_abs (scv_sct)
scv_sct	ncap_scv_clc (scv_sct, const char, scv_sct)
sym_sct *	ncap_sym_init (const char const sym_nm, double(fnc_dbl)(double), float(*fnc_flt)(float))
sym_sct *	ncap_scl_mk_sym (double val)
sym_sct *	ncap_sym_look (char *sym_nm)
var_sct *	ncap_var_abs (var_sct *)
var_sct *	ncap_var_fnc (var_sct , sym_sct )
var_sct *	ncap_var_init (char , prs_sct )
var_sct *	ncap_var_scv_add (var_sct *, scv_sct)
var_sct *	ncap_var_scv_mlt (var_sct *, scv_sct)
var_sct *	ncap_var_scv_sub (var_sct *, scv_sct)
var_sct *	ncap_var_scv_dvd (var_sct *, scv_sct)
var_sct *	ncap_var_scv_mod (var_sct *, scv_sct)
var_sct *	ncap_var_scv_pwr (var_sct *, scv_sct)
var_sct *	ncap_scv_var_dvd (scv_sct scv, var_sct *var)
var_sct *	ncap_scv_var_mod (scv_sct scv, var_sct *var)
var_sct *	ncap_scv_var_pwr (scv_sct scv, var_sct *var)
void	ncap_fnc_add (char nm, double(fnc_dbl)())
void	nco_lbr_vrs_prn (void)

nco/ncap.h File Reference

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation