scv_sct /* O [sct] Scalar value structure representing val */
ptr_unn_2_scv /* [fnc] Convert ptr_unn to scalar value structure */
(const nc_type type, /* I [enm] netCDF type of value */
ptr_unn val) /* I [sct] Value to convert to scalar value structure */
{
/* Purpose: Convert ptr_unn to scalar value structure
Assumes that val is initially cast to void
Does not convert cp (strings) as these are not handled by scv_sct
NB: netCDF attributes may contain multiple values
Only FIRST value in memory block is converted */
scv_sct scv;
(void)cast_void_nctype(type,&val);
switch(type) {
case NC_FLOAT:
scv.val.f=*val.fp;
break;
case NC_DOUBLE:
scv.val.d=*val.dp;
break;
case NC_INT:
scv.val.i=*val.ip;
break;
case NC_SHORT:
scv.val.s=*val.sp;
break;
case NC_BYTE:
scv.val.b=*val.bp;
break;
case NC_CHAR:
break; /* Do nothing */
case NC_UBYTE:
scv.val.ub=*val.ubp;
break;
case NC_USHORT:
scv.val.us=*val.usp;
break;
case NC_UINT:
scv.val.ui=*val.uip;
break;
case NC_INT64:
scv.val.i64=*val.i64p;
break;
case NC_UINT64:
scv.val.ui64=*val.ui64p;
break;
case NC_STRING:
scv.val.sng=*val.sngp;
break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
scv.type=type;
/* Do not uncast pointer as we are working with a copy */
return scv;
} /* end ptr_unn_2_scv */
void
rec_crd_chk /* Check for monotonicity of coordinate values */
(const var_sct * const var, /* I [sct] Coordinate to check for monotonicity */
const char * const fl_in, /* I [sng] Input filename */
const char * const fl_out, /* I [sng] Output filename */
const long idx_rec, /* I [idx] Index of record coordinate in input file */
const long idx_rec_out) /* I [idx] Index of record coordinate in output file */
{
/* Threads: Routine is thread safe and calls no unsafe routines */
/* Purpose: Check for monotonicity of coordinate values */
enum monotonic_direction{
decreasing, /* 0 */
increasing}; /* 1 */
static double rec_crd_val_lst;
static double rec_crd_val_crr;
static int monotonic_direction;
/* Use implicit type conversion */
switch(var->type){
case NC_FLOAT: rec_crd_val_crr=var->val.fp[0]; break;
case NC_DOUBLE: rec_crd_val_crr=var->val.dp[0]; break;
case NC_INT: rec_crd_val_crr=var->val.ip[0]; break;
case NC_SHORT: rec_crd_val_crr=var->val.sp[0]; break;
case NC_USHORT: rec_crd_val_crr=var->val.usp[0]; break;
case NC_UINT: rec_crd_val_crr=var->val.uip[0]; break;
case NC_INT64: rec_crd_val_crr=var->val.i64p[0]; break;
case NC_UINT64: rec_crd_val_crr=var->val.ui64p[0]; break;
case NC_BYTE: rec_crd_val_crr=var->val.bp[0]; break;
case NC_UBYTE: rec_crd_val_crr=var->val.ubp[0]; break;
case NC_CHAR: rec_crd_val_crr=var->val.cp[0]; break;
case NC_STRING: break; /* Do nothing */
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
if(idx_rec_out > 1){
if(((rec_crd_val_crr > rec_crd_val_lst) && monotonic_direction == decreasing) ||
((rec_crd_val_crr < rec_crd_val_lst) && monotonic_direction == increasing)){
if(idx_rec-1 == -1){
/* Inter-file non-monotonicity */
if(dbg_lvl_get() > 0) (void)fprintf(stderr,"%s: INFO/WARNING Inter-file non-monotonicity. Record coordinate \"%s\" does not monotonically %s between last specified record of previous input file (whose name is not cached locally and thus currently unavailable for printing) and first specified record (i.e., record index = %ld) of current input file (%s). This message is often informational only and may usually be safely ignored. It is quite common when joining files with \"wrapped\" record coordinates, e.g., joining a January file to a December file when the time coordinate is enumerated as day of year. It is also common when joining files which employ a \"time=base_time+time_offset\" convention. Sometimes, however, this message is a warning which signals that the user has joined files together in a different order than intended and that corrective action should be taken to re-order the input files. Output file %s will contain these non-monotonic record coordinate values (%f, %f) at record indices %ld, %ld.\n",prg_nm_get(),var->nm,(monotonic_direction == decreasing ? "decrease" : "increase"),idx_rec,fl_in,fl_out,rec_crd_val_lst,rec_crd_val_crr,idx_rec_out-1,idx_rec_out);
}else{
/* Intra-file non-monotonicity */
(void)fprintf(stderr,"%s: WARNING Intra-file non-monotonicity. Record coordinate \"%s\" does not monotonically %s between (input file %s record indices: %ld, %ld) (output file %s record indices %ld, %ld) record coordinate values %f, %f\n",prg_nm_get(),var->nm,(monotonic_direction == decreasing ? "decrease" : "increase"),fl_in,idx_rec-1,idx_rec,fl_out,idx_rec_out-1,idx_rec_out,rec_crd_val_lst,rec_crd_val_crr);
} /* end if Intra-file non-monotonicity */
} /* end if not monotonic */
}else if(idx_rec_out == 1){
if(rec_crd_val_crr > rec_crd_val_lst) monotonic_direction=increasing; else monotonic_direction=decreasing;
} /* end if */
rec_crd_val_lst=rec_crd_val_crr;
} /* end rec_crd_chk() */
const char * /* O [sng] String describing operation type */
nco_op_typ_to_rdc_sng /* [fnc] Convert operation type to string */
(const int nco_op_typ) /* I [enm] Operation type */
{
switch(nco_op_typ){
case nco_op_avg: return "mean";
case nco_op_mabs: return "mabs";
case nco_op_mebs: return "mebs";
case nco_op_mibs: return "mibs";
case nco_op_min: return "minimum";
case nco_op_max: return "maximum";
case nco_op_ttl: return "sum";
case nco_op_sqravg: return "sqravg";
case nco_op_avgsqr: return "avgsqr";
case nco_op_sqrt: return "sqrt";
case nco_op_rms: return "rms";
case nco_op_rmssdn: return "rmssdn";
default:
nco_dfl_case_nc_type_err(); break;
} /* end switch */
return False; /* Statement should not be reached */
} /* nco_op_typ_to_rdc_sng() */
nco_bool /* O [flg] NCO will attempt to chunk variable */
nco_is_chunkable /* [fnc] Will NCO attempt to chunk variable? */
(const nc_type nc_typ_in) /* I [enm] Type of input variable */
{
/* Purpose: Determine whether NCO should attempt to chunk a given type
Chunking certain variable types is not recommended, e.g., chunking NC_CHAR
and NC_BYTE makes no sense, because precision would needlessly be lost.
Routine should be consistent with nco_cnk_plc_typ_get()
NB: Routine is deprecated in favor of more flexible nco_cnk_plc_typ_get() */
const char fnc_nm[]="nco_is_chunkable()"; /* [sng] Function name */
(void)fprintf(stdout,"%s: ERROR deprecated routine %s should not be called\n",prg_nm_get(),fnc_nm);
nco_exit(EXIT_FAILURE);
switch(nc_typ_in){
case NC_FLOAT:
case NC_DOUBLE:
case NC_INT64:
case NC_UINT64:
case NC_INT:
case NC_UINT:
return True;
break;
case NC_SHORT:
case NC_USHORT:
case NC_CHAR:
case NC_BYTE:
case NC_UBYTE:
case NC_STRING:
return False;
break;
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* Some compilers, e.g., SGI cc, need return statement to end non-void functions */
return False;
} /* end nco_is_chunkable() */
var_sct * /* O [sct] Output netCDF variable structure representing val */
scl_mk_var /* [fnc] Convert scalar value of any type into NCO variable */
(val_unn val, /* I [frc] Scalar value to turn into netCDF variable */
const nc_type val_typ) /* I [enm] netCDF type of value */
{
/* Purpose: Turn scalar value of any type into NCO variable
Routine is just a wrapper for scl_ptr_mk_var()
This routine creates the void * argument needed for scl_ptr_mk_var(),
calls, scl_ptr_mk_var(), then passes back the result */
var_sct *var;
ptr_unn val_ptr_unn; /* [ptr] void pointer to value */
switch(val_typ) {
case NC_FLOAT:
val_ptr_unn.fp=&val.f;
break;
case NC_DOUBLE:
val_ptr_unn.dp=&val.d;
break;
case NC_INT:
val_ptr_unn.ip=&val.i;
break;
case NC_SHORT:
val_ptr_unn.sp=&val.s;
break;
case NC_CHAR:
val_ptr_unn.cp=&val.c;
break;
case NC_BYTE:
val_ptr_unn.bp=&val.b;
break;
case NC_UBYTE:
val_ptr_unn.ubp=&val.ub;
break;
case NC_USHORT:
val_ptr_unn.usp=&val.us;
break;
case NC_UINT:
val_ptr_unn.uip=&val.ui;
break;
case NC_INT64:
val_ptr_unn.i64p=&val.i64;
break;
case NC_UINT64:
val_ptr_unn.ui64p=&val.ui64;
break;
case NC_STRING:
val_ptr_unn.sngp=&val.sng;
break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
/* Un-typecast pointer to values after access */
(void)cast_nctype_void(val_typ,&val_ptr_unn);
var=scl_ptr_mk_var(val_ptr_unn,val_typ);
return var;
} /* end scl_mk_var() */
void
nco_scv_var_mod /* [fnc] Modulo scalar by variable */
(const nc_type type, /* I [enm] netCDF type of operands */
const long sz, /* I [nbr] Size (in elements) of array operands */
const int has_mss_val, /* I [flg] Flag for missing values */
ptr_unn mss_val, /* I [flg] Value of missing value */
scv_sct *scv, /* I [val] Pointer to scalar value (first operand) */
ptr_unn op2) /* I/O [val] Values of second operand */
{
/* Threads: Routine is thread safe and calls no unsafe routines */
/* Purpose: Take modulus of all values in scv by op2
Store result in op2 */
/* Scalar-variable modulus is currently defined as op2:=scv%op2 */
/* http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
__GNUC__ : Defined by gcc
__GNUG__ : Defined by g++, equivalent to (__GNUC__ && __cplusplus) */
#ifndef __GNUG__
float fmodf(float,float); /* Cannot insert fmodf() in ncap_sym_init() because it takes two arguments TODO #20 */
/* Sun cc math.h does not include fabsf() prototype
AIX xlc work fine with this prototype
HP-UX cc fails when fabsf() is prototyped */
#ifndef HPUX
float fabsf(float);
#endif /* HPUX */
#endif /* __GNUG__ */
long idx;
/* Typecast pointer to values before access */
(void)cast_void_nctype(type,&op2);
if(has_mss_val) (void)cast_void_nctype(type,&mss_val);
switch(type){
case NC_FLOAT:{
const float scv_flt=fabsf(scv->val.f);
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.fp[idx]=fmodf(scv_flt,op2.fp[idx]);
}else{
const float mss_val_flt=*mss_val.fp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.fp[idx] != mss_val_flt) op2.fp[idx]=fmodf(scv_flt,op2.fp[idx]);
} /* end for */
} /* end else */
break;
} /* endif NC_FLOAT */
case NC_DOUBLE:{
const double scv_dbl=fabs(scv->val.d);
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.dp[idx]=fmod(scv_dbl,op2.dp[idx]);
}else{
const double mss_val_dbl=*mss_val.dp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.dp[idx] != mss_val_dbl) op2.dp[idx]=fmod(scv_dbl,op2.dp[idx]);
} /* end for */
} /* end else */
break;
} /* endif NC_DOUBLE */
case NC_INT:{
const nco_int scv_ntg=scv->val.i;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ip[idx]=scv_ntg%op2.ip[idx];
}else{
const nco_int mss_val_ntg=*mss_val.ip; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ip[idx] != mss_val_ntg) op2.ip[idx]=scv_ntg%op2.ip[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_INT */
case NC_SHORT:{
const nco_short scv_short=scv->val.s;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.sp[idx]=scv_short%op2.sp[idx];
}else{
const nco_short mss_val_short=*mss_val.sp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.sp[idx] != mss_val_short) op2.sp[idx]=scv_short%op2.sp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_SHORT */
case NC_USHORT:{
const nco_ushort scv_ushort=scv->val.us;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.usp[idx]=scv_ushort%op2.usp[idx];
}else{
const nco_ushort mss_val_ushort=*mss_val.usp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.usp[idx] != mss_val_ushort) op2.usp[idx]=scv_ushort%op2.usp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_USHORT */
case NC_UINT:{
const nco_uint scv_uint=scv->val.ui;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.uip[idx]=scv_uint%op2.uip[idx];
}else{
const nco_uint mss_val_uint=*mss_val.uip; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.uip[idx] != mss_val_uint) op2.uip[idx]=scv_uint%op2.uip[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UINT */
case NC_INT64:{
const nco_int64 scv_int64=scv->val.i64;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.i64p[idx]=scv_int64%op2.i64p[idx];
}else{
const nco_int64 mss_val_int64=*mss_val.i64p; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.i64p[idx] != mss_val_int64) op2.i64p[idx]=scv_int64%op2.i64p[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_INT64 */
case NC_UINT64:{
const nco_uint64 scv_uint64=scv->val.ui64;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ui64p[idx]=scv_uint64%op2.ui64p[idx];
}else{
const nco_uint64 mss_val_uint64=*mss_val.ui64p; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ui64p[idx] != mss_val_uint64) op2.ui64p[idx]=scv_uint64%op2.ui64p[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UINT64 */
case NC_BYTE:{
const nco_byte scv_byte=scv->val.b;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.bp[idx]=scv_byte%op2.bp[idx];
}else{
const nco_byte mss_val_byte=*mss_val.bp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.bp[idx] != mss_val_byte) op2.bp[idx]=scv_byte%op2.bp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_BYTE */
case NC_UBYTE:{
const nco_ubyte scv_ubyte=scv->val.ub;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ubp[idx]=scv_ubyte%op2.ubp[idx];
}else{
const nco_ubyte mss_val_ubyte=*mss_val.ubp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ubp[idx] != mss_val_ubyte) op2.ubp[idx]=scv_ubyte%op2.ubp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UBYTE */
case NC_CHAR: break; /* Do nothing */
case NC_STRING: break; /* Do nothing */
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
} /* end nco_scv_var_mod */
void
nco_scv_var_dvd /* [fnc] Divide scalar by variable */
(const nc_type type, /* I [enm] netCDF type of operands */
const long sz, /* I [nbr] Size (in elements) of array operands */
const int has_mss_val, /* I [flg] Flag for missing values */
ptr_unn mss_val, /* I [flg] Value of missing value */
scv_sct *scv, /* I [val] Pointer to scalar value (first operand) */
ptr_unn op2) /* I/O [val] Values of second operand */
{
/* Threads: Routine is thread safe and calls no unsafe routines */
/* Purpose: Divide all values in scv by op2
Store result in second operand */
/* Scalar-variable division is currently defined as op2:=scv/op2 */
long idx;
/* Typecast pointer to values before access */
(void)cast_void_nctype(type,&op2);
if(has_mss_val) (void)cast_void_nctype(type,&mss_val);
switch(type){
case NC_FLOAT:{
const float scv_flt=scv->val.f;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.fp[idx]=scv_flt/op2.fp[idx];
}else{
const float mss_val_flt=*mss_val.fp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.fp[idx] != mss_val_flt) op2.fp[idx]=scv_flt/op2.fp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_FLOAT */
case NC_DOUBLE:{
const double scv_dbl=scv->val.d;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.dp[idx]=scv_dbl/op2.dp[idx];
}else{
const double mss_val_dbl=*mss_val.dp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.dp[idx] != mss_val_dbl) op2.dp[idx]=scv_dbl/op2.dp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_DOUBLE */
case NC_INT:{
const nco_int scv_ntg=scv->val.i;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ip[idx]=scv_ntg/op2.ip[idx];
}else{
const nco_int mss_val_ntg=*mss_val.ip; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ip[idx] != mss_val_ntg) op2.ip[idx]=scv_ntg/op2.ip[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_INT */
case NC_SHORT:{
const nco_short scv_short=scv->val.s;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.sp[idx]=scv_short/op2.sp[idx];
}else{
const nco_short mss_val_short=*mss_val.sp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.sp[idx] != mss_val_short) op2.sp[idx]=scv_short/op2.sp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_USHORT */
case NC_USHORT:{
const nco_ushort scv_ushort=scv->val.us;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.usp[idx]=scv_ushort/op2.usp[idx];
}else{
const nco_ushort mss_val_ushort=*mss_val.usp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.usp[idx] != mss_val_ushort) op2.usp[idx]=scv_ushort/op2.usp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_USHORT */
case NC_UINT:{
const nco_uint scv_uint=scv->val.ui;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.uip[idx]=scv_uint/op2.uip[idx];
}else{
const nco_uint mss_val_uint=*mss_val.uip; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.uip[idx] != mss_val_uint) op2.uip[idx]=scv_uint/op2.uip[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UINT */
case NC_INT64:{
const nco_int64 scv_int64=scv->val.i64;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.i64p[idx]=scv_int64/op2.i64p[idx];
}else{
const nco_int64 mss_val_int64=*mss_val.i64p; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.i64p[idx] != mss_val_int64) op2.i64p[idx]=scv_int64/op2.i64p[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_INT64 */
case NC_UINT64:{
const nco_uint64 scv_uint64=scv->val.ui64;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ui64p[idx]=scv_uint64/op2.ui64p[idx];
}else{
const nco_uint64 mss_val_uint64=*mss_val.ui64p; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ui64p[idx] != mss_val_uint64) op2.ui64p[idx]=scv_uint64/op2.ui64p[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UINT64 */
case NC_BYTE:{
const nco_byte scv_byte=scv->val.b;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.bp[idx]=scv_byte/op2.bp[idx];
}else{
const nco_byte mss_val_byte=*mss_val.bp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.bp[idx] != mss_val_byte) op2.bp[idx]=scv_byte/op2.bp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_BYTE */
case NC_UBYTE:{
const nco_ubyte scv_ubyte=scv->val.ub;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.ubp[idx]=scv_ubyte/op2.ubp[idx];
}else{
const nco_ubyte mss_val_ubyte=*mss_val.ubp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.ubp[idx] != mss_val_ubyte) op2.ubp[idx]=scv_ubyte/op2.ubp[idx];
} /* end for */
} /* end else */
break;
} /* endif NC_UBYTE */
case NC_CHAR: break; /* Do nothing */
case NC_STRING: break; /* Do nothing */
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* NB: it is not neccessary to un-typecast pointers to values after access
because we have only operated on local copies of them. */
} /* end nco_scv_var_dvd() */
void
nco_scv_var_pwr /* [fnc] Empower scalar by variable */
(const nc_type type, /* I [enm] netCDF type of operands */
const long sz, /* I [nbr] Size (in elements) of array operands */
const int has_mss_val, /* I [flg] Flag for missing values */
ptr_unn mss_val, /* I [flg] Value of missing value */
scv_sct *scv, /* I [val] Pointer to scalar value (first operand) */
ptr_unn op2) /* I/O [val] Values of second operand */
{
/* Purpose: Raise scv to power in var */
/* Scalar-variable empowerment is currently defined as op2:=scv^op2 */
long idx;
/* Typecast pointer to values before access */
(void)cast_void_nctype(type,&op2);
if(has_mss_val) (void)cast_void_nctype(type,&mss_val);
switch(type){
case NC_FLOAT:{
const float scv_flt=scv->val.f;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.fp[idx]=powf(scv_flt,op2.fp[idx]);
}else{
const float mss_val_flt=*mss_val.fp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.fp[idx] != mss_val_flt) op2.fp[idx]=powf(scv_flt,op2.fp[idx]);
} /* end for */
} /* end else */
break;
} /* end NC_FLOAT */
case NC_DOUBLE:{
const double scv_dbl=scv->val.d;
if(!has_mss_val){
for(idx=0;idx<sz;idx++) op2.dp[idx]=pow(scv_dbl,op2.dp[idx]);
}else{
const double mss_val_dbl=*mss_val.dp; /* Temporary variable reduces de-referencing */
for(idx=0;idx<sz;idx++){
if(op2.dp[idx] != mss_val_dbl) op2.dp[idx]=pow(scv_dbl,op2.dp[idx]);
} /* end for */
} /* end else */
break;
} /* end NC_DOUBLE */
/* fxm: nco322 Implement integer empowerment? GSL? */
case NC_INT: break; /* Do nothing */
case NC_SHORT: break; /* Do nothing */
case NC_USHORT: break; /* Do nothing */
case NC_UINT: break; /* Do nothing */
case NC_INT64: break; /* Do nothing */
case NC_UINT64: break; /* Do nothing */
case NC_BYTE: break; /* Do nothing */
case NC_UBYTE: break; /* Do nothing */
case NC_CHAR: break; /* Do nothing */
case NC_STRING: break; /* Do nothing */
default: nco_dfl_case_nc_type_err(); break;
}/* end switch */
/* NB: it is not neccessary to un-typecast pointers to values after access
because we have only operated on local copies of them. */
} /* end nco_var_scv_pwr */
aed_sct * /* O [sct] List of attribute edit structures */
nco_prs_aed_lst /* [fnc] Parse user-specified attribute edits into structure list */
(const int nbr_aed, /* I [nbr] Number of attributes in list */
X_CST_PTR_CST_PTR_Y(char,aed_arg)) /* I/O [sng] List of user-specified attribute edits (delimiters are changed to NULL on output */
{
/* Purpose: Parse name, type, size, and value elements of comma-separated list of attribute edit information
Routine merely evaluates syntax of input expressions
Routine does not validate attributes or variables against those present in input netCDF file */
/* Options are:
-a att_nm,var_nm,mode,att_typ,att_val (modifies attribute att_nm for the single variable var_nm)
-a att_nm,,mode,att_typ,att_val (modifies attribute att_nm for every variable in file)
If option -a is given with var_nm = NULL, then var_nm is expanded into every variable name in file
Thus attribute editing operation is performed on every variable in file.
mode,att_nm,att_typ,att_val (modifies global attribute att_nm for file)
This option may be combined with modes -a, -c, -d, or -o to specify
appending to, changing, deleting, or overwriting, any existing global attribute named att_nm
One mode must be set for each edited attribute: append (a), create (c), delete (d), modify (m), or overwrite (o).
-a: Attribute append mode
Append value att_val to current var_nm attribute att_nm value att_val, if any.
If var_nm does not have an attribute att_nm, there is not effect.
-c: Attribute create mode
Create variable var_nm attribute att_nm with att_val if att_nm does not yet exist.
If var_nm already has an attribute att_nm, there is not effect.
-d: Attribute delete mode
Delete current var_nm attribute att_nm.
If var_nm does not have an attribute att_nm, there is not effect.
-m: Attribute modify mode
Change value of current var_nm attribute att_nm to value att_val.
If var_nm does not have an attribute att_nm, there is not effect.
-o: Attribute overwrite mode
Write attribute att_nm with value att_val to variable var_nm, overwriting existing attribute att_nm, if any.
This is default mode.
*/
char **arg_lst;
const char * const dlm_sng=",";
const long idx_att_val_arg=4L; /* Number of required delimiters preceding attribute values in -a argument list */
aed_sct *aed_lst;
int idx;
int arg_nbr;
aed_lst=(aed_sct *)nco_malloc(nbr_aed*sizeof(aed_sct));
for(idx=0;idx<nbr_aed;idx++){
/* Process attribute edit specifications as normal text list */
arg_lst=nco_lst_prs_2D(aed_arg[idx],dlm_sng,&arg_nbr);
/* Check syntax */
if(
arg_nbr < 5 || /* Need more info */
/* arg_lst[0] == NULL || */ /* att_nm not specified */
arg_lst[2] == NULL || /* mode not specified */
(*(arg_lst[2]) != 'd' && (arg_lst[3] == NULL || (arg_lst[idx_att_val_arg] == NULL && *(arg_lst[3]) != 'c'))) || /* att_typ and att_val must be specified when mode is not delete, except that att_val = "" is valid for character type */
False){
(void)fprintf(stdout,"%s: ERROR in attribute edit specification %s\n",prg_nm_get(),aed_arg[idx]);
nco_exit(EXIT_FAILURE);
} /* end if */
/* Initialize structure */
/* aed strings not explicitly set by user remain NULL,
i.e., specifying default setting appears as if nothing was set.
Hopefully, in routines that follow, the branch followed by an aed for which
all default settings were specified (e.g.,"-a foo,,,,") will yield same result
as branch for which all defaults were set. */
aed_lst[idx].att_nm=NULL;
aed_lst[idx].var_nm=NULL;
aed_lst[idx].val.vp=NULL;
aed_lst[idx].type=NC_CHAR;
aed_lst[idx].mode=aed_overwrite;
aed_lst[idx].sz=-1L;
aed_lst[idx].id=-1;
/* Fill in structure */
if(arg_lst[0]) aed_lst[idx].att_nm=strdup(arg_lst[0]);
if(arg_lst[1]) aed_lst[idx].var_nm=strdup(arg_lst[1]);
/* fxm: Change these switches to string comparisons someday */
/* Set mode of current aed structure */
/* Convert single letter code to mode enum */
/* if(!strcmp("append",arg_lst[2])){aed_lst[idx].mode=aed_append;
}else if(!strcmp("create",arg_lst[2])){aed_lst[idx].mode=aed_create;
}else if(!strcmp("delete",arg_lst[2])){aed_lst[idx].mode=aed_delete;
}else if(!strcmp("modify",arg_lst[2])){aed_lst[idx].mode=aed_modify;
}else if(!strcmp("overwrite",arg_lst[2])){aed_lst[idx].mode=aed_overwrite;} */
switch(*(arg_lst[2])){
case 'a': aed_lst[idx].mode=aed_append; break;
case 'c': aed_lst[idx].mode=aed_create; break;
case 'd': aed_lst[idx].mode=aed_delete; break;
case 'm': aed_lst[idx].mode=aed_modify; break;
case 'o': aed_lst[idx].mode=aed_overwrite; break;
default:
(void)fprintf(stderr,"%s: ERROR `%s' is not a supported mode\n",prg_nm_get(),arg_lst[2]);
(void)fprintf(stderr,"%s: HINT: Valid modes are `a' = append, `c' = create,`d' = delete, `m' = modify, and `o' = overwrite",prg_nm_get());
nco_exit(EXIT_FAILURE);
break;
} /* end switch */
/* Attribute type and value do not matter if we are deleting it */
if(aed_lst[idx].mode != aed_delete){
/* Set type of current aed structure */
/* Convert single letter code to type enum */
switch(*(arg_lst[3])){
case 'f': aed_lst[idx].type=(nc_type)NC_FLOAT; break;
case 'd': aed_lst[idx].type=(nc_type)NC_DOUBLE; break;
case 'l':
case 'i': aed_lst[idx].type=(nc_type)NC_INT; break;
case 's': aed_lst[idx].type=(nc_type)NC_SHORT; break;
case 'c': aed_lst[idx].type=(nc_type)NC_CHAR; break;
case 'b': aed_lst[idx].type=(nc_type)NC_BYTE; break;
default:
if(!strcasecmp(arg_lst[3],"ub")) aed_lst[idx].type=(nc_type)NC_UBYTE;
else if(!strcasecmp(arg_lst[3],"us")) aed_lst[idx].type=(nc_type)NC_USHORT;
else if(!strcasecmp(arg_lst[3],"u") || !strcasecmp(arg_lst[3],"ui") || !strcasecmp(arg_lst[3],"ul")) aed_lst[idx].type=(nc_type)NC_UINT;
else if(!strcasecmp(arg_lst[3],"ll") || !strcasecmp(arg_lst[3],"int64")) aed_lst[idx].type=(nc_type)NC_INT64;
else if(!strcasecmp(arg_lst[3],"ull") || !strcasecmp(arg_lst[3],"uint64")) aed_lst[idx].type=(nc_type)NC_UINT64;
else if(!strcasecmp(arg_lst[3],"sng")) aed_lst[idx].type=(nc_type)NC_STRING;
else{
(void)fprintf(stderr,"%s: ERROR `%s' is not a supported netCDF data type\n",prg_nm_get(),arg_lst[3]);
(void)fprintf(stderr,"%s: HINT: Valid data types are `c' = char, `f' = float, `d' = double,`s' = short, 'l' = `i' = integer, `b' = byte",prg_nm_get());
nco_exit(EXIT_FAILURE);} /* end if error */
break;
} /* end switch */
/* Re-assemble string list values which inadvertently contain delimiters */
if(aed_lst[idx].type == NC_CHAR && arg_nbr > idx_att_val_arg+1){
/* Number of elements which must be concatenated into single string value */
long lmn_nbr;
lmn_nbr=arg_nbr-idx_att_val_arg;
if(dbg_lvl_get() >= nco_dbg_var) (void)fprintf(stdout,"%s: WARNING NC_CHAR (string) attribute is embedded with %li literal element delimiters (\"%s\"), re-assembling...\n",prg_nm_get(),lmn_nbr-1L,dlm_sng);
/* Rewrite list, splicing in original delimiter string */
/* fxm: TODO nco527 ncatted memory may be lost here */
arg_lst[idx_att_val_arg]=sng_lst_cat(arg_lst+idx_att_val_arg,lmn_nbr,dlm_sng);
/* Keep bookkeeping straight, just in case */
arg_nbr=idx_att_val_arg+1L;
lmn_nbr=1L;
} /* endif arg_nbr > idx_att_val_arg+1 */
/* Replace any C language '\X' escape codes with ASCII bytes */
if(aed_lst[idx].type == NC_CHAR) (void)sng_ascii_trn(arg_lst[idx_att_val_arg]);
/* Set size of current aed structure */
if(aed_lst[idx].type == NC_CHAR){
/* 20100409 Remove extra space formerly allocated for NUL-terminator
This caused each append to insert a NUL at end of NC_CHAR attributes
Multiple appends would then result in attributes pockmarked with NULs
Solves TODO nco985
Not yet sure there are no ill side-effects though... */
aed_lst[idx].sz=(arg_lst[idx_att_val_arg] == NULL) ? 0L : strlen(arg_lst[idx_att_val_arg]);
}else{
/* Number of elements of numeric types is determined by number of delimiters */
aed_lst[idx].sz=arg_nbr-idx_att_val_arg;
} /* end else */
/* Set value of current aed structure */
if(aed_lst[idx].type == NC_CHAR){
aed_lst[idx].val.cp=(nco_char *)strdup(arg_lst[idx_att_val_arg]);
}else{
double *val_arg_dbl=NULL_CEWI;
long long *val_arg_lng_lng=NULL_CEWI;
unsigned long long *val_arg_ulng_lng=NULL_CEWI;
long lmn;
aed_lst[idx].val.vp=(void *)nco_malloc(aed_lst[idx].sz*nco_typ_lng(aed_lst[idx].type));
/* Use type-appropriate conversion */
switch(aed_lst[idx].type){
case NC_FLOAT:
case NC_DOUBLE:
val_arg_dbl=(double *)nco_malloc(aed_lst[idx].sz*sizeof(double));
for(lmn=0L;lmn<aed_lst[idx].sz;lmn++){val_arg_dbl[lmn]=strtod(arg_lst[idx_att_val_arg+lmn],(char **)NULL);} break;
case NC_BYTE:
case NC_INT:
case NC_SHORT:
case NC_INT64:
val_arg_lng_lng=(long long *)nco_malloc(aed_lst[idx].sz*sizeof(long long));
for(lmn=0L;lmn<aed_lst[idx].sz;lmn++){val_arg_lng_lng[lmn]=strtoll(arg_lst[idx_att_val_arg+lmn],(char **)NULL,10);} break;
case NC_CHAR:
case NC_UBYTE:
case NC_USHORT:
case NC_UINT:
case NC_UINT64:
val_arg_ulng_lng=(unsigned long long *)nco_malloc(aed_lst[idx].sz*sizeof(unsigned long long));
for(lmn=0L;lmn<aed_lst[idx].sz;lmn++){val_arg_ulng_lng[lmn]=strtoull(arg_lst[idx_att_val_arg+lmn],(char **)NULL,10);} break;
case NC_STRING: break;
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* Copy and typecast entire array of values, using implicit coercion rules of C */
/* 20011001: Use explicit coercion rules to quiet C++ compiler warnings */
switch(aed_lst[idx].type){
case NC_FLOAT: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.fp[lmn]=(float)val_arg_dbl[lmn];} break;
case NC_DOUBLE: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.dp[lmn]=(double)val_arg_dbl[lmn];} break;
case NC_INT: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.ip[lmn]=(nco_int)val_arg_lng_lng[lmn];} break;
case NC_SHORT: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.sp[lmn]=(nco_short)val_arg_lng_lng[lmn];} break;
case NC_CHAR: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.cp[lmn]=(nco_char)val_arg_ulng_lng[lmn];} break;
case NC_BYTE: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.bp[lmn]=(nco_byte)val_arg_lng_lng[lmn];} break;
case NC_UBYTE: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.ubp[lmn]=(nco_ubyte)val_arg_ulng_lng[lmn];} break;
case NC_USHORT: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.usp[lmn]=(nco_ushort)val_arg_ulng_lng[lmn];} break;
case NC_UINT: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.uip[lmn]=(nco_uint)val_arg_ulng_lng[lmn];} break;
case NC_INT64: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.i64p[lmn]=(nco_int64)val_arg_lng_lng[lmn];} break;
case NC_UINT64: for(lmn=0L;lmn<aed_lst[idx].sz;lmn++) {aed_lst[idx].val.ui64p[lmn]=(nco_uint64)val_arg_ulng_lng[lmn];} break;
case NC_STRING: break;
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* Free array used to hold input values */
if(val_arg_dbl) val_arg_dbl=(double *)nco_free(val_arg_dbl);
if(val_arg_lng_lng) val_arg_lng_lng=(long long *)nco_free(val_arg_lng_lng);
if(val_arg_ulng_lng) val_arg_ulng_lng=(unsigned long long *)nco_free(val_arg_ulng_lng);
} /* end else */
/* Un-typecast pointer to values after access */
(void)cast_nctype_void(aed_lst[idx].type,&aed_lst[idx].val);
} /* end if mode is not delete */
arg_lst=nco_sng_lst_free(arg_lst,arg_nbr);
} /* end loop over aed */
if(dbg_lvl_get() >= nco_dbg_io){
for(idx=0;idx<nbr_aed;idx++){
(void)fprintf(stderr,"aed_lst[%d].att_nm = %s\n",idx,aed_lst[idx].att_nm);
(void)fprintf(stderr,"aed_lst[%d].var_nm = %s\n",idx,aed_lst[idx].var_nm == NULL ? "NULL" : aed_lst[idx].var_nm);
(void)fprintf(stderr,"aed_lst[%d].id = %i\n",idx,aed_lst[idx].id);
(void)fprintf(stderr,"aed_lst[%d].sz = %li\n",idx,aed_lst[idx].sz);
(void)fprintf(stderr,"aed_lst[%d].type = %s\n",idx,nco_typ_sng(aed_lst[idx].type));
/* (void)fprintf(stderr,"aed_lst[%d].val = %s\n",idx,aed_lst[idx].val);*/
(void)fprintf(stderr,"aed_lst[%d].mode = %i\n",idx,aed_lst[idx].mode);
} /* end loop over idx */
} /* end debug */
return aed_lst;
} /* end nco_prs_aed_lst() */
void
nco_aed_prc /* [fnc] Process single attribute edit for single variable */
(const int nc_id, /* I [id] Input netCDF file ID */
const int var_id, /* I [id] ID of variable on which to perform attribute editing */
const aed_sct aed) /* I [sct] Structure containing information necessary to edit */
{
/* Purpose: Process single attribute edit for single variable */
/* If var_id == NC_GLOBAL ( = -1) then global attribute will be edited */
#ifdef NCO_NETCDF4_AND_FILLVALUE
char att_nm_tmp[]="eulaVlliF_"; /* String of same length as "_FillValue" for name hack with netCDF4 */
nco_bool flg_netCDF4=False; /* [flg] File format is netCDF4 */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
char att_nm[NC_MAX_NAME];
char var_nm[NC_MAX_NAME];
/* NB: netCDF2 specifies att_sz is type int, netCDF3 and netCDF4 use size_t */
int nbr_att; /* [nbr] Number of attributes */
int rcd=NC_NOERR; /* [rcd] Return code */
long att_sz;
nc_type att_typ;
void *att_val_new=NULL;
if(var_id == NC_GLOBAL){
/* Get number of global attributes in file */
(void)nco_inq(nc_id,(int *)NULL,(int *)NULL,&nbr_att,(int *)NULL);
(void)strcpy(var_nm,"Global");
}else{
/* Get name and number of attributes for variable */
(void)nco_inq_var(nc_id,var_id,var_nm,(nc_type *)NULL,(int *)NULL,(int *)NULL,&nbr_att);
} /* end else */
/* Query attribute metadata when attribute name was specified */
if(aed.att_nm) rcd=nco_inq_att_flg(nc_id,var_id,aed.att_nm,&att_typ,&att_sz);
/* Before changing metadata, change missing values to new missing value if warranted
This capability is add-on feature not implemented too cleanly or efficiently
If every variable has "_FillValue" attribute and "_FillValue" is changed
globally, then algorithm goes into and out of define mode for each variable,
rather than collecting all information in first pass and replacing all data in second pass.
This is because ncatted was originally designed to change only metadata and so was
architected differently from other NCO operators. */
if(
aed.att_nm /* Linux strcmp() dumps core if attribute name is blank */
&& strcmp(aed.att_nm,nco_mss_val_sng_get()) == 0 /* Current attribute is "_FillValue" */
&& var_id != NC_GLOBAL /* Current attribute is not global */
&& (aed.mode == aed_modify || aed.mode == aed_overwrite) /* Modifying or overwriting existing value */
&& rcd == NC_NOERR /* Only when existing _FillValue attribute is modified */
&& att_sz == 1L /* Old _FillValue attribute must be of size 1 */
&& aed.sz == 1L /* New _FillValue attribute must be of size 1 */
){
int *dmn_id;
long *dmn_sz;
long *dmn_srt;
long idx;
long var_sz=long_CEWI;
ptr_unn mss_val_crr;
ptr_unn mss_val_new;
ptr_unn var_val;
var_sct *var=NULL_CEWI;
if(dbg_lvl_get() >= nco_dbg_std) (void)fprintf(stdout,"%s: INFO Replacing missing value data in variable %s\n",prg_nm_get(),var_nm);
/* Take file out of define mode */
(void)nco_enddef(nc_id);
/* Initialize (partially) variable structure */
var=(var_sct *)nco_malloc(sizeof(var_sct));
var->nc_id=nc_id;
var->id=var_id;
var->sz=1L;
/* Get type of variable and number of dimensions */
(void)nco_inq_var(nc_id,var_id,(char *)NULL,&var->type,&var->nbr_dim,(int *)NULL,(int *)NULL);
dmn_id=(int *)nco_malloc(var->nbr_dim*sizeof(int));
dmn_sz=(long *)nco_malloc(var->nbr_dim*sizeof(long));
dmn_srt=(long *)nco_malloc(var->nbr_dim*sizeof(long));
(void)nco_inq_vardimid(nc_id,var_id,dmn_id);
/* Get dimension sizes and construct variable size */
for(idx=0;idx<var->nbr_dim;idx++){
(void)nco_inq_dimlen(nc_id,dmn_id[idx],dmn_sz+idx);
var->sz*=dmn_sz[idx];
dmn_srt[idx]=0L;
} /* end loop over dim */
var->dmn_id=dmn_id;
var->cnt=dmn_sz;
var->srt=dmn_srt;
/* Place nco_var_get() code inline since var struct is not truly complete */
if((var->val.vp=(void *)nco_malloc_flg(var->sz*nco_typ_lng(var->type))) == NULL){
(void)fprintf(stdout,"%s: ERROR Unable to malloc() %ld*%lu bytes in nco_aed_prc()\n",prg_nm_get(),var->sz,(unsigned long)nco_typ_lng(var->type));
nco_exit(EXIT_FAILURE);
} /* end if */
if(var->sz > 1L){
(void)nco_get_vara(nc_id,var_id,var->srt,var->cnt,var->val.vp,var->type);
}else{
(void)nco_get_var1(nc_id,var_id,var->srt,var->val.vp,var->type);
} /* end else */
/* Get current missing value attribute */
var->mss_val.vp=NULL;
var->has_mss_val=nco_mss_val_get(nc_id,var);
/* Sanity check */
if(var->has_mss_val == False){
(void)fprintf(stdout,"%s: ERROR variable %s does not have \"%s\" attribute in nco_aed_prc()\n",prg_nm_get(),var_nm,nco_mss_val_sng_get());
nco_exit(EXIT_FAILURE);
} /* end if */
/* Shortcuts to avoid indirection */
var_val=var->val;
var_sz=var->sz;
/* Get new and old missing values in same type as variable */
mss_val_crr.vp=(void *)nco_malloc(att_sz*nco_typ_lng(var->type));
mss_val_new.vp=(void *)nco_malloc(aed.sz*nco_typ_lng(var->type));
(void)nco_val_cnf_typ(var->type,var->mss_val,var->type,mss_val_crr);
(void)nco_val_cnf_typ(aed.type,aed.val,var->type,mss_val_new);
/* Typecast pointer to values before access */
(void)cast_void_nctype(var->type,&var_val);
(void)cast_void_nctype(var->type,&mss_val_crr);
(void)cast_void_nctype(var->type,&mss_val_new);
switch(var->type){
case NC_FLOAT: for(idx=0L;idx<var_sz;idx++) {if(var_val.fp[idx] == *mss_val_crr.fp) var_val.fp[idx]=*mss_val_new.fp;} break;
case NC_DOUBLE: for(idx=0L;idx<var_sz;idx++) {if(var_val.dp[idx] == *mss_val_crr.dp) var_val.dp[idx]=*mss_val_new.dp;} break;
case NC_INT: for(idx=0L;idx<var_sz;idx++) {if(var_val.ip[idx] == *mss_val_crr.ip) var_val.ip[idx]=*mss_val_new.ip;} break;
case NC_SHORT: for(idx=0L;idx<var_sz;idx++) {if(var_val.sp[idx] == *mss_val_crr.sp) var_val.sp[idx]=*mss_val_new.sp;} break;
case NC_CHAR: for(idx=0L;idx<var_sz;idx++) {if(var_val.cp[idx] == *mss_val_crr.cp) var_val.cp[idx]=*mss_val_new.cp;} break;
case NC_BYTE: for(idx=0L;idx<var_sz;idx++) {if(var_val.bp[idx] == *mss_val_crr.bp) var_val.bp[idx]=*mss_val_new.bp;} break;
case NC_UBYTE: for(idx=0L;idx<var_sz;idx++) {if(var_val.ubp[idx] == *mss_val_crr.ubp) var_val.ubp[idx]=*mss_val_new.ubp;} break;
case NC_USHORT: for(idx=0L;idx<var_sz;idx++) {if(var_val.usp[idx] == *mss_val_crr.usp) var_val.usp[idx]=*mss_val_new.usp;} break;
case NC_UINT: for(idx=0L;idx<var_sz;idx++) {if(var_val.uip[idx] == *mss_val_crr.uip) var_val.uip[idx]=*mss_val_new.uip;} break;
case NC_INT64: for(idx=0L;idx<var_sz;idx++) {if(var_val.i64p[idx] == *mss_val_crr.i64p) var_val.i64p[idx]=*mss_val_new.i64p;} break;
case NC_UINT64: for(idx=0L;idx<var_sz;idx++) {if(var_val.ui64p[idx] == *mss_val_crr.ui64p) var_val.ui64p[idx]=*mss_val_new.ui64p;} break;
case NC_STRING: for(idx=0L;idx<var_sz;idx++) {if(var_val.sngp[idx] == *mss_val_crr.sngp) var_val.sngp[idx]=*mss_val_new.sngp;} break;
default: nco_dfl_case_nc_type_err(); break;
} /* end switch */
/* Un-typecast the pointer to values after access */
(void)cast_nctype_void(var->type,&var_val);
(void)cast_nctype_void(var->type,&mss_val_crr);
(void)cast_nctype_void(var->type,&mss_val_new);
/* Write to disk */
if(var->nbr_dim == 0){
(void)nco_put_var1(nc_id,var_id,var->srt,var->val.vp,var->type);
}else{ /* end if variable is scalar */
(void)nco_put_vara(nc_id,var_id,var->srt,var->cnt,var->val.vp,var->type);
} /* end else */
/* Free memory */
mss_val_crr.vp=nco_free(mss_val_crr.vp);
mss_val_new.vp=nco_free(mss_val_new.vp);
var->mss_val.vp=nco_free(var->mss_val.vp);
var->val.vp=nco_free(var->val.vp);
var->dmn_id=(int *)nco_free(var->dmn_id);
var->srt=(long *)nco_free(var->srt);
var->cnt=(long *)nco_free(var->cnt);
/* 20050704 try and use nco_free() to avoid valgrind error message */
var=(var_sct *)nco_free(var);
/* Put file back in define mode */
(void)nco_redef(nc_id);
} /* end if replacing missing value data */
/* Change metadata (as written, this must be done after _FillValue data is replaced) */
#ifdef NCO_NETCDF4_AND_FILLVALUE
/* Bold hack which gets around problem of modifying netCDF4 "_FillValue" attributes
netCDF4 does not allow this by default, though netCDF3 does
Change attribute name to att_nm_tmp, modify value, then restore name */
/* Check if file is netCDF3 classic with netCDF4 library
If so, do not kludge. NB: create global variable for output file format? */
{ /* scope for fl_fmt temporary */
int fl_fmt;
(void)nco_inq_format(nc_id,&fl_fmt);
flg_netCDF4=(fl_fmt==NC_FORMAT_NETCDF4 || fl_fmt==NC_FORMAT_NETCDF4_CLASSIC);
} /* end scope */
if(flg_netCDF4 && !strcmp(aed.att_nm,nco_mss_val_sng_get()) && aed.mode != aed_delete){
if(aed.mode != aed_create) (void)nco_rename_att(nc_id,var_id,aed.att_nm,att_nm_tmp);
strcpy(aed.att_nm,att_nm_tmp);
} /* endif libnetCDF may have netCDF4 restrictions */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
switch(aed.mode){
case aed_append:
if(rcd == NC_NOERR){
/* Append to existing attribute value */
if(aed.type != att_typ){
(void)fprintf(stdout,"%s: ERROR %s attribute %s is of type %s not %s, unable to append\n",prg_nm_get(),var_nm,aed.att_nm,nco_typ_sng(att_typ),nco_typ_sng(aed.type));
nco_exit(EXIT_FAILURE);
} /* end if */
att_val_new=(void *)nco_malloc((att_sz+aed.sz)*nco_typ_lng(aed.type));
(void)nco_get_att(nc_id,var_id,aed.att_nm,(void *)att_val_new,aed.type);
/* NB: Following assumes sizeof(char) = 1 byte */
(void)memcpy((void *)((char *)att_val_new+att_sz*nco_typ_lng(aed.type)),
(void *)aed.val.vp,
aed.sz*nco_typ_lng(aed.type));
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,att_sz+aed.sz,att_val_new);
att_val_new=nco_free(att_val_new);
}else{
/* Create new attribute */
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
} /* end else */
break;
case aed_create:
if(rcd != NC_NOERR) (void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
case aed_delete:
/* Delete specified attribute if attribute name was specified... */
if(aed.att_nm){
/* ...and if attribute is known to exist from previous inquire call... */
if(rcd == NC_NOERR) (void)nco_del_att(nc_id,var_id,aed.att_nm);
}else{
/* ...else delete all attributes for this variable... */
while(nbr_att){
(void)nco_inq_attname(nc_id,var_id,nbr_att-1,att_nm);
(void)nco_del_att(nc_id,var_id,att_nm);
nbr_att--;
} /* end while */
} /* end else */
break;
case aed_modify:
if(rcd == NC_NOERR) (void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
case aed_overwrite:
(void)nco_put_att(nc_id,var_id,aed.att_nm,aed.type,aed.sz,aed.val.vp);
break;
default:
break;
} /* end switch */
#ifdef NCO_NETCDF4_AND_FILLVALUE
if(flg_netCDF4 && !strcmp(aed.att_nm,att_nm_tmp) && aed.mode != aed_delete){
(void)nco_rename_att(nc_id,var_id,att_nm_tmp,nco_mss_val_sng_get());
/* Restore original name (space already allocated) */
strcpy(aed.att_nm,nco_mss_val_sng_get());
} /* !flg_netCDF4 */
#endif /* !NCO_NETCDF4_AND_FILLVALUE */
} /* end nco_aed_prc() */
void
nco_ppc_ini /* Set PPC based on user specifications */
(const int nc_id, /* I [id] netCDF input file ID */
int *dfl_lvl, /* O [enm] Deflate level */
const int fl_out_fmt, /* I [enm] Output file format */
char * const ppc_arg[], /* I [sng] List of user-specified PPCs */
const int ppc_arg_nbr, /* I [nbr] Number of PPC specified */
trv_tbl_sct * const trv_tbl) /* I/O [sct] Traversal table */
{
int ppc_arg_idx; /* [idx] Index over ppc_arg (i.e., separate invocations of "--ppc var1[,var2]=val") */
int ppc_var_idx; /* [idx] Index over ppc_lst (i.e., all names explicitly specified in all "--ppc var1[,var2]=val" options) */
int ppc_var_nbr=0;
kvm_sct *ppc_lst; /* [sct] List of all PPC specifications */
kvm_sct kvm;
if(fl_out_fmt == NC_FORMAT_NETCDF4 || fl_out_fmt == NC_FORMAT_NETCDF4_CLASSIC){
/* If user did not explicitly set deflate level for this file ... */
if(*dfl_lvl == NCO_DFL_LVL_UNDEFINED){
*dfl_lvl=1;
if(nco_dbg_lvl_get() >= nco_dbg_std) (void)fprintf(stderr,"%s: INFO Precision-Preserving Compression (PPC) automatically activating file-wide deflation level = %d\n",nco_prg_nm_get(),*dfl_lvl);
} /* endif */
}else{
if(nco_dbg_lvl_get() >= nco_dbg_std) (void)fprintf(stderr,"%s: INFO Requested Precision-Preserving Compression (PPC) on netCDF3 output dataset. Unlike netCDF4, netCDF3 does not support internal compression. To take full advantage of PPC consider writing file as netCDF4 enhanced (e.g., %s -4 ...) or classic (e.g., %s -7 ...). Or consider compressing the netCDF3 file afterwards with, e.g., gzip or bzip2. File must then be uncompressed with, e.g., gunzip or bunzip2 before netCDF readers will recognize it. See http://nco.sf.net/nco.html#ppc for more information on PPC strategies.\n",nco_prg_nm_get(),nco_prg_nm_get(),nco_prg_nm_get());
} /* endelse */
ppc_lst=(kvm_sct *)nco_malloc(NC_MAX_VARS*sizeof(kvm_sct));
/* Parse PPCs */
for(ppc_arg_idx=0;ppc_arg_idx<ppc_arg_nbr;ppc_arg_idx++){
if(!strstr(ppc_arg[ppc_arg_idx],"=")){
(void)fprintf(stdout,"%s: Invalid --ppc specification: %s. Must contain \"=\" sign.\n",nco_prg_nm_get(),ppc_arg[ppc_arg_idx]);
if(ppc_lst) ppc_lst=(kvm_sct *)nco_free(ppc_lst);
nco_exit(EXIT_FAILURE);
} /* endif */
kvm=nco_sng2kvm(ppc_arg[ppc_arg_idx]);
/* nco_sng2kvm() converts argument "--ppc one,two=3" into kvm.key="one,two" and kvm.val=3
Then nco_lst_prs_2D() converts kvm.key into two items, "one" and "two", with the same value, 3 */
if(kvm.key){
int var_idx; /* [idx] Index over variables in current PPC argument */
int var_nbr; /* [nbr] Number of variables in current PPC argument */
char **var_lst;
var_lst=nco_lst_prs_2D(kvm.key,",",&var_nbr);
for(var_idx=0;var_idx<var_nbr;var_idx++){ /* Expand multi-variable specification */
ppc_lst[ppc_var_nbr].key=strdup(var_lst[var_idx]);
ppc_lst[ppc_var_nbr].val=strdup(kvm.val);
ppc_var_nbr++;
} /* end for */
var_lst=nco_sng_lst_free(var_lst,var_nbr);
} /* end if */
} /* end for */
/* PPC "default" specified, set all non-coordinate variables to default first */
for(ppc_var_idx=0;ppc_var_idx<ppc_var_nbr;ppc_var_idx++){
if(!strcasecmp(ppc_lst[ppc_var_idx].key,"default")){
nco_ppc_set_dflt(nc_id,ppc_lst[ppc_var_idx].val,trv_tbl);
break; /* Only one default is needed */
} /* endif */
} /* end for */
/* Set explicit, non-default PPCs that can overwrite default */
for(ppc_var_idx=0;ppc_var_idx<ppc_var_nbr;ppc_var_idx++){
if(!strcasecmp(ppc_lst[ppc_var_idx].key,"default")) continue;
nco_ppc_set_var(ppc_lst[ppc_var_idx].key,ppc_lst[ppc_var_idx].val,trv_tbl);
} /* end for */
/* Unset PPC and flag for all variables with excessive PPC
Operational definition of maximum PPC is maximum decimal precision of float/double = FLT_DIG/DBL_DIG = 7/15 */
const int nco_max_ppc_dbl=15;
const int nco_max_ppc_flt=7;
/* Maximum digits for integers taken based on LONG_MAX ... from limits.h */
const int nco_max_ppc_short=5;
const int nco_max_ppc_ushort=5;
const int nco_max_ppc_int=10;
const int nco_max_ppc_uint=10;
const int nco_max_ppc_int64=19;
const int nco_max_ppc_uint64=20;
int nco_max_ppc=int_CEWI;
for(unsigned idx_tbl=0;idx_tbl<trv_tbl->nbr;idx_tbl++){
if(trv_tbl->lst[idx_tbl].ppc != NC_MAX_INT){
switch(trv_tbl->lst[idx_tbl].var_typ){
case NC_FLOAT: nco_max_ppc=nco_max_ppc_flt; break;
case NC_DOUBLE: nco_max_ppc=nco_max_ppc_dbl; break;
case NC_SHORT: nco_max_ppc=nco_max_ppc_short; break;
case NC_USHORT: nco_max_ppc=nco_max_ppc_ushort; break;
case NC_INT: nco_max_ppc=nco_max_ppc_int; break;
case NC_UINT: nco_max_ppc=nco_max_ppc_uint; break;
case NC_INT64: nco_max_ppc=nco_max_ppc_int64; break;
case NC_UINT64: nco_max_ppc=nco_max_ppc_uint64; break;
/* Do nothing for non-numeric types ...*/
case NC_CHAR:
case NC_BYTE:
case NC_UBYTE:
case NC_STRING: break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
switch(trv_tbl->lst[idx_tbl].var_typ){
/* Floating point types */
case NC_FLOAT:
case NC_DOUBLE:
if(trv_tbl->lst[idx_tbl].ppc > nco_max_ppc){
if(trv_tbl->lst[idx_tbl].flg_nsd) (void)fprintf(stdout,"%s: INFO Number of Significant Digits (NSD) requested = %d too high for variable %s which is of type %s. No quantization or rounding will be performed for this variable. HINT: Maximum precisions for NC_FLOAT and NC_DOUBLE are %d and %d, respectively.\n",nco_prg_nm_get(),trv_tbl->lst[idx_tbl].ppc,trv_tbl->lst[idx_tbl].nm,nco_typ_sng(trv_tbl->lst[idx_tbl].var_typ),nco_max_ppc_flt,nco_max_ppc_dbl);
trv_tbl->lst[idx_tbl].ppc=NC_MAX_INT;
} /* endif */
break;
/* Integer types */
case NC_SHORT:
case NC_USHORT:
case NC_INT:
case NC_UINT:
case NC_INT64:
case NC_UINT64:
if(
/* ...rounding requested with NSD or ... */
(trv_tbl->lst[idx_tbl].flg_nsd) ||
/* ...more rounding requested with DSD than available or ... */
(!trv_tbl->lst[idx_tbl].flg_nsd && (trv_tbl->lst[idx_tbl].ppc < -1*nco_max_ppc)) ||
/* ...more precision requested than integers have or ... */
(!trv_tbl->lst[idx_tbl].flg_nsd && (trv_tbl->lst[idx_tbl].ppc >= 0)) ||
False)
trv_tbl->lst[idx_tbl].ppc=NC_MAX_INT;
break;
case NC_CHAR: /* Do nothing for non-numeric types ...*/
case NC_BYTE:
case NC_UBYTE:
case NC_STRING:
trv_tbl->lst[idx_tbl].ppc=NC_MAX_INT;
break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
/* For consistency reset flg_nsd as well */
if(trv_tbl->lst[idx_tbl].ppc == NC_MAX_INT) trv_tbl->lst[idx_tbl].flg_nsd=True;
} /* endif */
} /* endfor */
if(ppc_lst) ppc_lst=nco_kvm_lst_free(ppc_lst,ppc_var_nbr);
} /* end nco_ppc_ini() */
void
nco_ppc_bitmask /* [fnc] Mask-out insignificant bits of significand */
(const int nsd, /* I [nbr] Number of significant digits, i.e., arithmetic precision */
const nc_type type, /* I [enm] netCDF type of operand */
const long sz, /* I [nbr] Size (in elements) of operand */
const int has_mss_val, /* I [flg] Flag for missing values */
ptr_unn mss_val, /* I [val] Value of missing value */
ptr_unn op1) /* I/O [val] Values of first operand */
{
/* Threads: Routine is thread safe and calls no unsafe routines */
/* Purpose: Mask-out insignificant bits of op1 values */
/* Rounding is currently defined as op1:=bitmask(op1,ppc) */
/* This routine implements the Bit Grooming Number of Significant Digits (NSD) algorithm
NSD based on absolute precision, i.e., number of digits in significand and in decimal scientific notation
DSD based on precision relative to decimal point, i.e., number of digits before/after decimal point
DSD is more often used colloquially, e.g., "thermometers measure temperature accurate to 1 degree C"
NSD is more often used scientifically, e.g., "thermometers measure temperature to three significant digits"
These statements are both equivalent and describe the same instrument and data
If data are stored in C or K then optimal specifications for each algorithm would be DSD=0 and NSD=3
However, if data are stored in mK (milli-Kelvin) then optimal specifications would be DSD=-3 and NSD=3
In other words, the number of significant digits (NSD) does not depend on the units of storage, but DSD does
Hence NSD is more instrinsic and portable than DSD
NSD requires only bit-shifting and bit-masking, no floating point math
DSD is implemented with rounding techniques that rely on floating point math
This makes DSD subject to accompanying overflow and underflow problems when exponent near MAX_EXP/2
Thus NSD is faster, more accurate, and less ambiguous than DSD
Nevertheless many users think in terms of DSD not NSD
Terminology:
Decimal Precision is number of significant digits following decimal point (DSD)
Arithmetic Precision is number of significant digits (NSD)
"Arithmetic precision can also be defined with reference to a fixed number of decimal places (the number of digits following the decimal point). This second definition is useful in applications where the number of digits in the fractional part has particular importance, but it does not follow the rules of significance arithmetic." -- Wikipedia
"A common convention in science and engineering is to express accuracy and/or precision implicitly by means of significant figures. Here, when not explicitly stated, the margin of error is understood to be one-half the value of the last significant place. For instance, a recording of 843.6 m, or 843.0 m, or 800.0 m would imply a margin of 0.05 m (the last significant place is the tenths place), while a recording of 8,436 m would imply a margin of error of 0.5 m (the last significant digits are the units)." -- Wikipedia
Test NSD:
nc3tonc4 -o --quantize=ppc_big=3,ppc_bgr=3,ppc_flt=3 --quiet=1 ~/nco/data/in.nc ~/foo_n34.nc
ncks -D 1 -4 -O -C -v ppc_big,ppc_bgr,ppc_flt --ppc .?=3 ~/nco/data/in.nc ~/foo.nc
ncks -C -v ppc_big,ppc_bgr ~/foo.nc
ncks -s '%16.12e\n' -C -H -v ppc_big,ppc_bgr ~/foo_n34.nc */
/* IEEE single- and double-precision significands have 24 and 53 bits of precision (prc_bnr)
Decimal digits of precision (prc_dcm) obtained via prc_dcm=prc_bnr*ln(2)/ln(10) = 7.22 and 15.95, respectively
Binary digits of precision (prc_bnr) obtained via prc_bnr=prc_dcm*ln(10)/ln(2) */
/* Use constants defined in math.h */
const double bit_per_dcm_dgt_prc=M_LN10/M_LN2; /* 3.32 [frc] Bits per decimal digit of precision */
const int bit_xpl_nbr_sgn_flt=23; /* [nbr] Bits 0-22 of SP significands are explicit. Bit 23 is implicitly 1. */
const int bit_xpl_nbr_sgn_dbl=53; /* [nbr] Bits 0-52 of DP significands are explicit. Bit 53 is implicitly 1. */
double prc_bnr_xct; /* [nbr] Binary digits of precision, exact */
int bit_xpl_nbr_sgn=int_CEWI; /* [nbr] Number of explicit bits in significand */
int bit_xpl_nbr_zro; /* [nbr] Number of explicit bits to zero */
long idx;
unsigned int *u32_ptr;
unsigned int msk_f32_u32_zro;
unsigned int msk_f32_u32_one;
unsigned long int *u64_ptr;
unsigned long int msk_f64_u64_zro;
unsigned long int msk_f64_u64_one;
unsigned short prc_bnr_ceil; /* [nbr] Exact binary digits of precision rounded-up */
unsigned short prc_bnr_xpl_rqr; /* [nbr] Explicitly represented binary digits required to retain */
/* Only floating point types can be quantized */
if(type != NC_FLOAT && type != NC_DOUBLE) return;
/* Disallow unreasonable quantization */
assert(nsd > 0);
assert(nsd <= 16);
/* How many bits to preserve? */
prc_bnr_xct=nsd*bit_per_dcm_dgt_prc;
/* Be conservative, round upwards */
prc_bnr_ceil=(unsigned short)ceil(prc_bnr_xct);
/* First bit is implicit not explicit but corner cases prevent our taking advantage of this */
//prc_bnr_xpl_rqr=prc_bnr_ceil-1;
//prc_bnr_xpl_rqr=prc_bnr_ceil;
prc_bnr_xpl_rqr=prc_bnr_ceil+1;
if(type == NC_DOUBLE) prc_bnr_xpl_rqr++; /* Seems necessary for double-precision ppc=array(1.234567,1.0e-6,$dmn) */
/* 20150128: Hand-tuning shows we can sacrifice one or two more bits for almost all cases
20150205: However, small integers are an exception. In fact they require two more bits, at least for NSD=1.
Thus minimum threshold to preserve half of least significant digit (LSD) is prc_bnr_xpl_rqr=prc_bnr_ceil
Decrementing prc_bnr_xpl_rqr by one or two more bits produces maximum errors that exceed half the LSD
ncra -4 -O -C --ppc default=1 --ppc one=1 -p ~/nco/data in.nc in.nc ~/foo.nc
ncks -H -v Q.. --cdl ~/foo.nc | m */
/* 20150126: fxm casting pointers is tricky with this routine. Avoid for now. */
/* Typecast pointer to values before access */
//(void)cast_void_nctype(type,&op1);
//if(has_mss_val) (void)cast_void_nctype(type,&mss_val);
if(type == NC_FLOAT && prc_bnr_xpl_rqr >= bit_xpl_nbr_sgn_flt) return;
if(type == NC_DOUBLE && prc_bnr_xpl_rqr >= bit_xpl_nbr_sgn_dbl) return;
switch(type){
case NC_FLOAT:
bit_xpl_nbr_sgn=bit_xpl_nbr_sgn_flt;
bit_xpl_nbr_zro=bit_xpl_nbr_sgn-prc_bnr_xpl_rqr;
assert(bit_xpl_nbr_zro <= bit_xpl_nbr_sgn-NCO_PPC_BIT_XPL_NBR_MIN);
u32_ptr=op1.uip;
/* Create mask */
msk_f32_u32_zro=0u; /* Zero all bits */
msk_f32_u32_zro=~msk_f32_u32_zro; /* Turn all bits to ones */
/* Bit Shave mask for AND: Left shift zeros into bits to be rounded, leave ones in untouched bits */
msk_f32_u32_zro <<= bit_xpl_nbr_zro;
/* Bit Set mask for OR: Put ones into bits to be set, zeros in untouched bits */
msk_f32_u32_one=~msk_f32_u32_zro;
if(nco_baa_cnv_get() == nco_baa_grm){
/* Bit-Groom: alternately shave and set LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx+=2L) u32_ptr[idx]&=msk_f32_u32_zro;
for(idx=1L;idx<sz;idx+=2L)
if(u32_ptr[idx] != 0U) /* Never quantize upwards floating point values of zero */
u32_ptr[idx]|=msk_f32_u32_one;
}else{
const float mss_val_flt=*mss_val.fp;
for(idx=0L;idx<sz;idx+=2L)
if(op1.fp[idx] != mss_val_flt) u32_ptr[idx]&=msk_f32_u32_zro;
for(idx=1L;idx<sz;idx+=2L)
if(op1.fp[idx] != mss_val_flt && u32_ptr[idx] != 0U) u32_ptr[idx]|=msk_f32_u32_one;
} /* end else */
}else if(nco_baa_cnv_get() == nco_baa_shv){
/* Bit-Shave: always shave LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) u32_ptr[idx]&=msk_f32_u32_zro;
}else{
const float mss_val_flt=*mss_val.fp;
for(idx=0L;idx<sz;idx++)
if(op1.fp[idx] != mss_val_flt) u32_ptr[idx]&=msk_f32_u32_zro;
} /* end else */
}else if(nco_baa_cnv_get() == nco_baa_set){
/* Bit-Set: always set LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx++)
if(u32_ptr[idx] != 0U) /* Never quantize upwards floating point values of zero */
u32_ptr[idx]|=msk_f32_u32_one;
}else{
const float mss_val_flt=*mss_val.fp;
for(idx=0L;idx<sz;idx++)
if(op1.fp[idx] != mss_val_flt) u32_ptr[idx]|=msk_f32_u32_one;
} /* end else */
}else abort();
break;
case NC_DOUBLE:
bit_xpl_nbr_sgn=bit_xpl_nbr_sgn_dbl;
bit_xpl_nbr_zro=bit_xpl_nbr_sgn-prc_bnr_xpl_rqr;
assert(bit_xpl_nbr_zro <= bit_xpl_nbr_sgn-NCO_PPC_BIT_XPL_NBR_MIN);
u64_ptr=(unsigned long int *)op1.ui64p;
/* Create mask */
msk_f64_u64_zro=0ul; /* Zero all bits */
msk_f64_u64_zro=~msk_f64_u64_zro; /* Turn all bits to ones */
/* Bit Shave mask for AND: Left shift zeros into bits to be rounded, leave ones in untouched bits */
msk_f64_u64_zro <<= bit_xpl_nbr_zro;
/* Bit Set mask for OR: Put ones into bits to be set, zeros in untouched bits */
msk_f64_u64_one=~msk_f64_u64_zro;
if(nco_baa_cnv_get() == nco_baa_grm){
/* Bit-Groom: alternately shave and set LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx+=2L) u64_ptr[idx]&=msk_f64_u64_zro;
for(idx=1L;idx<sz;idx+=2L)
if(u64_ptr[idx] != 0UL) /* Never quantize upwards floating point values of zero */
u64_ptr[idx]|=msk_f64_u64_one;
}else{
const double mss_val_dbl=*mss_val.dp;
for(idx=0L;idx<sz;idx+=2L)
if(op1.dp[idx] != mss_val_dbl) u64_ptr[idx]&=msk_f64_u64_zro;
for(idx=1L;idx<sz;idx+=2L)
if(op1.dp[idx] != mss_val_dbl && u64_ptr[idx] != 0UL) u64_ptr[idx]|=msk_f64_u64_one;
} /* end else */
}else if(nco_baa_cnv_get() == nco_baa_shv){
/* Bit-Shave: always shave LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) u64_ptr[idx]&=msk_f64_u64_zro;
}else{
const double mss_val_dbl=*mss_val.dp;
for(idx=0L;idx<sz;idx++)
if(op1.dp[idx] != mss_val_dbl) u64_ptr[idx]&=msk_f64_u64_zro;
} /* end else */
}else if(nco_baa_cnv_get() == nco_baa_set){
/* Bit-Set: always set LSBs */
if(!has_mss_val){
for(idx=0L;idx<sz;idx++)
if(u64_ptr[idx] != 0UL) /* Never quantize upwards floating point values of zero */
u64_ptr[idx]|=msk_f64_u64_one;
}else{
const double mss_val_dbl=*mss_val.dp;
for(idx=0L;idx<sz;idx++)
if(op1.dp[idx] != mss_val_dbl && u64_ptr[idx] != 0UL) u64_ptr[idx]|=msk_f64_u64_one;
} /* end else */
}else abort();
break;
case NC_INT: /* Do nothing for non-floating point types ...*/
case NC_SHORT:
case NC_CHAR:
case NC_BYTE:
case NC_UBYTE:
case NC_USHORT:
case NC_UINT:
case NC_INT64:
case NC_UINT64:
case NC_STRING: break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
/* 20150126: fxm casting pointers is tricky with this routine. Avoid for now. */
/* NB: it is not neccessary to un-typecast pointers to values after access
because we have only operated on local copies of them. */
} /* end nco_ppc_bitmask() */
void
nco_ppc_around /* [fnc] Replace op1 values by their values rounded to decimal precision prc */
(const int ppc, /* I [nbr] Precision-preserving compression, i.e., number of total or decimal significant digits */
const nc_type type, /* I [enm] netCDF type of operand */
const long sz, /* I [nbr] Size (in elements) of operand */
const int has_mss_val, /* I [flg] Flag for missing values */
ptr_unn mss_val, /* I [val] Value of missing value */
ptr_unn op1) /* I/O [val] Values of first operand */
{
/* Threads: Routine is thread safe and calls no unsafe routines */
/* Purpose: Replace op1 values by their values rounded to decimal precision ppc
Similar to numpy.around() function, hence the name around()
Based on implementation by Jeff Whitaker for netcdf4-python described here:
http://netcdf4-python.googlecode.com/svn/trunk/docs/netCDF4-module.html
which invokes the numpy.around() function documented here:
http://docs.scipy.org/doc/numpy/reference/generated/numpy.around.html#numpy.around
A practical discussion of rounding is at
http://stackoverflow.com/questions/20388071/what-are-the-under-the-hood-differences-between-round-and-numpy-round
This mentions the () NumPy source code:
https://github.com/numpy/numpy/blob/7b2f20b406d27364c812f7a81a9c901afbd3600c/numpy/core/src/multiarray/calculation.c#L588
Manually determine scale:
ncap2 -O -v -s 'ppc=2;ppc_abs=abs(ppc);bit_nbr_xct=ppc_abs*ln(10.)/ln(2.);bit_nbr_int=ceil(bit_nbr_xct);scale=pow(2.0,bit_nbr_int);' ~/nco/data/in.nc ~/foo.nc
ncks -H ~/foo.nc
Test full algorithm:
ncks -4 -O -C -v ppc_dbl,ppc_big --ppc ppc_dbl=3 --ppc ppc_big=-2 ~/nco/data/in.nc ~/foo.nc
Compare to Jeff Whitaker's nc3tonc4 results:
nc3tonc4 -o --quantize=ppc_dbl=3,ppc_big=-2 ~/nco/data/in.nc ~/foo.nc
ncks -H -C -v ppc_dbl,ppc_big ~/foo.nc */
/* Rounding is currently defined as op1:=around(op1,ppc) */
/* Use constants defined in math.h */
const double bit_per_dcm_dgt_prc=M_LN10/M_LN2; /* 3.32 [frc] Bits per decimal digit of precision */
double scale; /* [frc] Number by which to scale data to achieve rounding */
float scalef; /* [frc] Number by which to scale data to achieve rounding */
int bit_nbr; /* [nbr] Number of bits required to exceed pow(10,-ppc) */
int ppc_abs; /* [nbr] Absolute value of precision */
long idx;
/* Only numeric types can be quantized */
if(type == NC_CHAR || type == NC_BYTE || type == NC_UBYTE || type == NC_STRING) return;
ppc_abs=abs(ppc);
assert(ppc_abs <= 16);
switch(ppc_abs){
case 0:
bit_nbr=0;
scale=1.0;
break;
case 1:
bit_nbr=4;
scale=16.0;
break;
case 2:
bit_nbr=7;
scale=128.0;
break;
case 3:
bit_nbr=10;
scale=1024.0;
break;
case 4:
bit_nbr=14;
scale=16384.0;
break;
case 5:
bit_nbr=17;
scale=131072.0;
break;
case 6:
bit_nbr=20;
scale=1048576.0;
break;
default:
bit_nbr=(int)ceil(ppc_abs*bit_per_dcm_dgt_prc);
scale=pow(2.0,bit_nbr);
break;
} /* end switch */
if(ppc < 0) scale=1.0/scale;
if(nco_dbg_lvl_get() == nco_dbg_sbr) (void)fprintf(stdout,"%s: INFO nco_ppc_around() reports ppc = %d, bit_nbr= %d, scale = %g\n",nco_prg_nm_get(),ppc,bit_nbr,scale);
/* Typecast pointer to values before access */
(void)cast_void_nctype(type,&op1);
if(has_mss_val) (void)cast_void_nctype(type,&mss_val);
scalef=(float)scale;
switch(type){
case NC_FLOAT:
/* By default do float arithmetic in double precision before converting back to float
Allow --flt to override
NB: Use rint() not lrint()
If ignoring this advice, be sure to bound calls to lrint(), e.g.,
rint_arg=scale*op1.fp[idx];
if(rint_arg > LONG_MIN && rint_arg < LONG_MAX) op1.fp[idx]=(float)lrint(scale*op1.fp[idx])/scale; */
if(!has_mss_val){
if(nco_rth_cnv_get() == nco_rth_flt_flt)
for(idx=0L;idx<sz;idx++) op1.fp[idx]=rintf(scalef*op1.fp[idx])/scalef;
else
for(idx=0L;idx<sz;idx++) op1.fp[idx]=(float)(rint(scale*op1.fp[idx])/scale); /* Coerce to avoid implicit conversions warning */
}else{
const float mss_val_flt=*mss_val.fp;
if(nco_rth_cnv_get() == nco_rth_flt_flt){
for(idx=0;idx<sz;idx++)
if(op1.fp[idx] != mss_val_flt)
op1.fp[idx]=rintf(scalef*op1.fp[idx])/scalef;
}else{
for(idx=0;idx<sz;idx++)
if(op1.fp[idx] != mss_val_flt)
op1.fp[idx]=(float)(rint(scale*op1.fp[idx])/scale); /* Coerce to avoid implicit conversions warning */
} /* end else */
} /* end else */
break;
case NC_DOUBLE:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.dp[idx]=rint(scale*op1.dp[idx])/scale;
}else{
const double mss_val_dbl=*mss_val.dp;
for(idx=0;idx<sz;idx++)
if(op1.dp[idx] != mss_val_dbl) op1.dp[idx]=rint(scale*op1.dp[idx])/scale;
} /* end else */
break;
case NC_SHORT:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.sp[idx]=(short int)lrint(scale*op1.sp[idx])/scale;
}else{
const nco_int mss_val_short=*mss_val.sp;
for(idx=0;idx<sz;idx++)
if(op1.sp[idx] != mss_val_short) op1.sp[idx]=(short int)lrint(scale*op1.sp[idx])/scale;
} /* end else */
break;
case NC_USHORT:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.usp[idx]=(unsigned short int)lrint(scale*op1.usp[idx])/scale;
}else{
const nco_ushort mss_val_ushort=*mss_val.usp;
for(idx=0;idx<sz;idx++)
if(op1.usp[idx] != mss_val_ushort) op1.usp[idx]=(unsigned short int)lrint(scale*op1.usp[idx])/scale;
} /* end else */
break;
case NC_INT:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.ip[idx]=lrint(scale*op1.ip[idx])/scale;
}else{
const nco_int mss_val_int=*mss_val.ip;
for(idx=0;idx<sz;idx++)
if(op1.ip[idx] != mss_val_int) op1.ip[idx]=lrint(scale*op1.ip[idx])/scale;
} /* end else */
break;
case NC_UINT:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.uip[idx]=(unsigned int)lrint(scale*op1.uip[idx])/scale;
}else{
const nco_uint mss_val_uint=*mss_val.uip;
for(idx=0;idx<sz;idx++)
if(op1.uip[idx] != mss_val_uint) op1.uip[idx]=(unsigned int)lrint(scale*op1.uip[idx])/scale;
} /* end else */
break;
case NC_INT64:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.i64p[idx]=lrint(scale*op1.i64p[idx])/scale;
}else{
const nco_int64 mss_val_int64=*mss_val.i64p;
for(idx=0;idx<sz;idx++)
if(op1.i64p[idx] != mss_val_int64) op1.i64p[idx]=lrint(scale*op1.i64p[idx])/scale;
} /* end else */
break;
case NC_UINT64:
if(!has_mss_val){
for(idx=0L;idx<sz;idx++) op1.ui64p[idx]=(unsigned long)lrint(scale*op1.ui64p[idx])/scale;
}else{
const nco_uint64 mss_val_uint64=*mss_val.ui64p;
for(idx=0;idx<sz;idx++)
if(op1.ui64p[idx] != mss_val_uint64) op1.ui64p[idx]=(unsigned long)lrint(scale*op1.ui64p[idx])/scale;
} /* end else */
break;
case NC_CHAR: /* Do nothing for non-numeric types ...*/
case NC_BYTE:
case NC_UBYTE:
case NC_STRING: break;
default:
nco_dfl_case_nc_type_err();
break;
} /* end switch */
/* NB: it is not neccessary to un-typecast pointers to values after access
because we have only operated on local copies of them. */
} /* end nco_ppc_around() */
