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
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 */
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_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() */
