nco/nco_scl_utl.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netcdf.h>
#include "nco_netcdf.h"
#include "nco.h"
#include "nco_cnf_typ.h"
#include "nco_ctl.h"
#include "nco_mmr.h"
#include "nco_var_utl.h"

Include dependency graph for nco_scl_utl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
var_sct *	scl_dbl_mk_var (const double val)
var_sct *	scl_mk_var (val_unn val, const nc_type val_typ)
var_sct *	scl_ptr_mk_var (const ptr_unn val_ptr_unn, const nc_type val_typ)
double	ptr_unn_2_scl_dbl (const ptr_unn val, const nc_type type)
scv_sct	ptr_unn_2_scv (const nc_type type, ptr_unn val)

---

Function Documentation

double ptr_unn_2_scl_dbl (  const ptr_unn  val, const nc_type  type )

Definition at line 99 of file nco_scl_utl.c. References ptr_unn::dp, EXIT_FAILURE, NC_DOUBLE, nco_exit(), nco_free(), nco_malloc(), nco_typ_lng(), nco_val_cnf_typ(), prg_nm_get(), type, and ptr_unn::vp. Referenced by nco_var_pck(). { /* Purpose: Return first element of NCO variable converted to a scalar double */ double scl_dbl; /* [sct] Double precision value of scale_factor */ ptr_unn ptr_unn_scl_dbl; /* [unn] Pointer union to double precision value of first element */ /* Variable must be in memory already */ if(val.vp == NULL){ (void)fprintf(stdout,"%s: ERROR ptr_unn_2_scl_dbl() called with empty val.vp\n",prg_nm_get()); nco_exit(EXIT_FAILURE); } /* endif */ /* Valid memory address exists */ ptr_unn_scl_dbl.vp=(void *)nco_malloc(nco_typ_lng(NC_DOUBLE)); /* [unn] Pointer union to double precision value of first element */ (void)nco_val_cnf_typ(type,val,NC_DOUBLE,ptr_unn_scl_dbl); scl_dbl=ptr_unn_scl_dbl.dp[0]; ptr_unn_scl_dbl.vp=nco_free(ptr_unn_scl_dbl.vp); return scl_dbl; } /* end ptr_unn_2_scl_dbl() */

scv_sct ptr_unn_2_scv (  const nc_type  type, ptr_unn  val )

Definition at line 126 of file nco_scl_utl.c. References val_unn::b, ptr_unn::bp, cast_void_nctype(), val_unn::d, ptr_unn::dp, val_unn::f, ptr_unn::fp, val_unn::l, ptr_unn::lp, NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT, nco_dfl_case_nc_type_err(), val_unn::s, ptr_unn::sp, scv_sct::type, type, and scv_sct::val. Referenced by nco_var_upk(). { /* Purpose: Convert ptr_unn to scalar value structure Assumes that val is initially cast to void Note 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.l =*val.lp; 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 */ 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 */

var_sct* scl_dbl_mk_var (  const double  val  )

Definition at line 13 of file nco_scl_utl.c. References var_sct_tag::nbr_dim, NC_DOUBLE, nco_malloc(), nco_typ_lng(), var_sct_tag::nm, var_sct_tag::type, var_sct_tag::val, var_dfl_set(), and ptr_unn::vp. { /* Purpose: Convert scalar double into netCDF variable Routine duplicates most functions of nco_var_fll() Both functions should share as much initialization code as possible */ var_sct *var; var=(var_sct *)nco_malloc(sizeof(var_sct)); /* Set defaults */ (void)var_dfl_set(var); /* [fnc] Set defaults for each member of variable structure */ /* Overwrite defaults with values appropriate for artificial variable */ var->nm=(char *)strdup("Internally generated variable"); var->nbr_dim=0; var->type=NC_DOUBLE; var->val.vp=(void *)nco_malloc(nco_typ_lng(var->type)); (void)memcpy((void *)var->val.vp,(const void *)(&val),nco_typ_lng(var->type)); return var; } /* end scl_dbl_mk_var() */

var_sct* scl_mk_var (  val_unn  val, const nc_type  val_typ )

Definition at line 37 of file nco_scl_utl.c. References val_unn::b, ptr_unn::bp, val_unn::c, cast_nctype_void(), ptr_unn::cp, val_unn::d, ptr_unn::dp, val_unn::f, ptr_unn::fp, val_unn::l, ptr_unn::lp, NC_BYTE, NC_CHAR, NC_DOUBLE, NC_FLOAT, NC_INT, NC_SHORT, nco_dfl_case_nc_type_err(), val_unn::s, scl_ptr_mk_var(), and ptr_unn::sp. Referenced by main(), nco_var_dfn(), and nco_var_pck(). { /* 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.lp=&val.l; 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; 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() */

var_sct* scl_ptr_mk_var (  const ptr_unn  val_ptr_unn, const nc_type  val_typ )

Definition at line 68 of file nco_scl_utl.c. References var_sct_tag::nbr_dim, nco_malloc(), nco_typ_lng(), var_sct_tag::nm, var_sct_tag::type, var_sct_tag::val, var_dfl_set(), and ptr_unn::vp. Referenced by nco_var_pck(), and scl_mk_var(). { /* Purpose: Convert void pointer to scalar of any type into NCO variable Routine duplicates many functions of nco_var_fll() Both functions should share as much initialization code as possible */ var_sct *var; var=(var_sct *)nco_malloc(sizeof(var_sct)); /* Set defaults */ (void)var_dfl_set(var); /* [fnc] Set defaults for each member of variable structure */ /* Overwrite defaults with values appropriate for artificial variable */ var->nm=(char *)strdup("Internally generated variable"); var->nbr_dim=0; var->type=val_typ; /* Allocate new space here so that variable can eventually be deleted and associated memory free()'d */ /* free(val_ptr_unn.vp) is unpredictable since val_ptr_unn may point to constant data, e.g., a constant in scl_mk_var */ var->val.vp=(void *)nco_malloc(nco_typ_lng(var->type)); /* Copy value into variable structure */ (void)memcpy((void *)var->val.vp,val_ptr_unn.vp,nco_typ_lng(var->type)); return var; } /* end scl_ptr_mk_var() */

---