From 2a488e7803e80e661093decdd5f9fee9edaa4f46 Mon Sep 17 00:00:00 2001 From: John Kerl Date: Fri, 2 Oct 2015 21:26:48 -0400 Subject: [PATCH] neaten --- c/mapping/lrec_evaluators.c | 40 +++++++++--------- c/mapping/mlr_val.c | 79 ++++++++++++++++++----------------- c/mapping/mlr_val.h | 82 ++++++++++++++++++------------------- 3 files changed, 100 insertions(+), 101 deletions(-) diff --git a/c/mapping/lrec_evaluators.c b/c/mapping/lrec_evaluators.c index c54ce31a4..2a69bcbd2 100644 --- a/c/mapping/lrec_evaluators.c +++ b/c/mapping/lrec_evaluators.c @@ -111,7 +111,7 @@ mv_t lrec_evaluator_f_f_func(lrec_t* prec, context_t* pctx, void* pvstate) { NULL_OR_ERROR_OUT(val1); mt_get_double_nullable(&val1); NULL_OUT(val1); - if (val1.type != MT_DOUBLE) + if (val1.type != MT_FLOAT) return MV_ERROR; return pstate->pfunc(&val1); @@ -142,14 +142,14 @@ mv_t lrec_evaluator_f_ff_func(lrec_t* prec, context_t* pctx, void* pvstate) { NULL_OR_ERROR_OUT(val1); mt_get_double_nullable(&val1); NULL_OUT(val1); - if (val1.type != MT_DOUBLE) + if (val1.type != MT_FLOAT) return MV_ERROR; mv_t val2 = pstate->parg2->pevaluator_func(prec, pctx, pstate->parg2->pvstate); NULL_OR_ERROR_OUT(val2); mt_get_double_nullable(&val2); NULL_OUT(val2); - if (val2.type != MT_DOUBLE) + if (val2.type != MT_FLOAT) return MV_ERROR; return pstate->pfunc(&val1, &val2); @@ -178,13 +178,13 @@ mv_t lrec_evaluator_f_ff_nullable_func(lrec_t* prec, context_t* pctx, void* pvst mv_t val1 = pstate->parg1->pevaluator_func(prec, pctx, pstate->parg1->pvstate); ERROR_OUT(val1); mt_get_double_nullable(&val1); - if (val1.type != MT_DOUBLE && val1.type != MT_NULL) + if (val1.type != MT_FLOAT && val1.type != MT_NULL) return MV_ERROR; mv_t val2 = pstate->parg2->pevaluator_func(prec, pctx, pstate->parg2->pvstate); ERROR_OUT(val2); mt_get_double_nullable(&val2); - if (val2.type != MT_DOUBLE && val2.type != MT_NULL) + if (val2.type != MT_FLOAT && val2.type != MT_NULL) return MV_ERROR; return pstate->pfunc(&val1, &val2); @@ -243,10 +243,10 @@ mv_t lrec_evaluator_s_f_func(lrec_t* prec, context_t* pctx, void* pvstate) { lrec_evaluator_s_f_state_t* pstate = pvstate; mv_t val1 = pstate->parg1->pevaluator_func(prec, pctx, pstate->parg1->pvstate); NULL_OR_ERROR_OUT(val1); - if (val1.type == MT_DOUBLE) { + if (val1.type == MT_FLOAT) { ; } else if (val1.type == MT_INT) { - val1.type = MT_DOUBLE; + val1.type = MT_FLOAT; val1.u.fltv = (double)val1.u.intv; } else { return MV_ERROR; @@ -279,7 +279,7 @@ mv_t lrec_evaluator_s_i_func(lrec_t* prec, context_t* pctx, void* pvstate) { NULL_OR_ERROR_OUT(val1); if (val1.type == MT_INT) { ; - } else if (val1.type == MT_DOUBLE) { + } else if (val1.type == MT_FLOAT) { val1.type = MT_INT; val1.u.intv = (long long)val1.u.fltv; } else { @@ -620,7 +620,7 @@ mv_t lrec_evaluator_field_name_func(lrec_t* prec, context_t* pctx, void* pvstate } else { double fltv; if (mlr_try_double_from_string(string, &fltv)) { - return (mv_t) {.type = MT_DOUBLE, .u.fltv = fltv}; + return (mv_t) {.type = MT_FLOAT, .u.fltv = fltv}; } else { return (mv_t) {.type = MT_STRING, .u.strv = mlr_strdup_or_die(string)}; } @@ -659,7 +659,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_literal(char* string) { double fltv; if (mlr_try_double_from_string(string, &fltv)) { - pstate->literal = (mv_t) {.type = MT_DOUBLE, .u.fltv = fltv}; + pstate->literal = (mv_t) {.type = MT_FLOAT, .u.fltv = fltv}; pevaluator->pevaluator_func = lrec_evaluator_double_literal_func; } else { pstate->literal = (mv_t) {.type = MT_STRING, .u.strv = mlr_strdup_or_die(string)}; @@ -728,7 +728,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_FILENUM() { // ---------------------------------------------------------------- mv_t lrec_evaluator_PI_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_DOUBLE, .u.fltv = M_PI}; + return (mv_t) {.type = MT_FLOAT, .u.fltv = M_PI}; } lrec_evaluator_t* lrec_evaluator_alloc_from_PI() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); @@ -739,7 +739,7 @@ lrec_evaluator_t* lrec_evaluator_alloc_from_PI() { // ---------------------------------------------------------------- mv_t lrec_evaluator_E_func(lrec_t* prec, context_t* pctx, void* pvstate) { - return (mv_t) {.type = MT_DOUBLE, .u.fltv = M_E}; + return (mv_t) {.type = MT_FLOAT, .u.fltv = M_E}; } lrec_evaluator_t* lrec_evaluator_alloc_from_E() { lrec_evaluator_t* pevaluator = mlr_malloc_or_die(sizeof(lrec_evaluator_t)); @@ -1285,12 +1285,12 @@ static char * test3() { printf("newval log(x) = %s\n", mt_describe_val(valplogx)); printf("newval 2*log(x) = %s\n", mt_describe_val(valp2logx)); - mu_assert_lf(valp2.type == MT_DOUBLE); - mu_assert_lf(valp4.type == MT_DOUBLE); - mu_assert_lf(valpx.type == MT_DOUBLE); - mu_assert_lf(valpx2.type == MT_DOUBLE); - mu_assert_lf(valplogx.type == MT_DOUBLE); - mu_assert_lf(valp2logx.type == MT_DOUBLE); + mu_assert_lf(valp2.type == MT_FLOAT); + mu_assert_lf(valp4.type == MT_FLOAT); + mu_assert_lf(valpx.type == MT_FLOAT); + mu_assert_lf(valpx2.type == MT_FLOAT); + mu_assert_lf(valplogx.type == MT_FLOAT); + mu_assert_lf(valp2logx.type == MT_FLOAT); mu_assert_lf(valp2.u.fltv == 2.0); mu_assert_lf(valp4.u.fltv == 4.0); @@ -1320,8 +1320,8 @@ static char * test3() { printf("newval log(x) = %s\n", mt_describe_val(valplogx)); printf("newval 2*log(x) = %s\n", mt_describe_val(valp2logx)); - mu_assert_lf(valp2.type == MT_DOUBLE); - mu_assert_lf(valp4.type == MT_DOUBLE); + mu_assert_lf(valp2.type == MT_FLOAT); + mu_assert_lf(valp4.type == MT_FLOAT); mu_assert_lf(valpx.type == MT_NULL); mu_assert_lf(valpx2.type == MT_NULL); mu_assert_lf(valplogx.type == MT_NULL); diff --git a/c/mapping/mlr_val.c b/c/mapping/mlr_val.c index 5a6c6746b..934b82075 100644 --- a/c/mapping/mlr_val.c +++ b/c/mapping/mlr_val.c @@ -25,7 +25,7 @@ char* mt_describe_type(int type) { case MT_NULL: return "T_NULL"; break; case MT_ERROR: return "T_ERROR"; break; case MT_BOOL: return "T_BOOL"; break; - case MT_DOUBLE: return "T_DOUBLE"; break; + case MT_FLOAT: return "T_FLOAT"; break; case MT_INT: return "T_INT"; break; case MT_STRING: return "T_STRING"; break; default: return "???"; break; @@ -46,7 +46,7 @@ char* mt_format_val(mv_t* pval) { case MT_BOOL: return mlr_strdup_or_die(pval->u.boolv ? "true" : "false"); break; - case MT_DOUBLE: + case MT_FLOAT: // xxx what is worst-case here ... string = mlr_malloc_or_die(32); sprintf(string, MLR_GLOBALS.ofmt, pval->u.fltv); @@ -96,7 +96,7 @@ void mt_get_double_strict(mv_t* pval) { return; if (pval->type == MT_ERROR) return; - if (pval->type == MT_DOUBLE) + if (pval->type == MT_FLOAT) return; if (pval->type == MT_STRING) { double fltv; @@ -104,11 +104,11 @@ void mt_get_double_strict(mv_t* pval) { pval->type = MT_ERROR; pval->u.intv = 0; } else { - pval->type = MT_DOUBLE; + pval->type = MT_FLOAT; pval->u.fltv = fltv; } } else if (pval->type == MT_INT) { - pval ->type = MT_DOUBLE; + pval ->type = MT_FLOAT; pval->u.fltv = (double)pval->u.intv; } else if (pval->type == MT_BOOL) { pval->type = MT_ERROR; @@ -126,7 +126,7 @@ void mt_get_double_nullable(mv_t* pval) { return; if (pval->type == MT_ERROR) return; - if (pval->type == MT_DOUBLE) + if (pval->type == MT_FLOAT) return; if (pval->type == MT_STRING) { double fltv; @@ -137,11 +137,11 @@ void mt_get_double_nullable(mv_t* pval) { pval->type = MT_ERROR; pval->u.intv = 0; } else { - pval->type = MT_DOUBLE; + pval->type = MT_FLOAT; pval->u.fltv = fltv; } } else if (pval->type == MT_INT) { - pval ->type = MT_DOUBLE; + pval ->type = MT_FLOAT; pval->u.fltv = (double)pval->u.intv; } else if (pval->type == MT_BOOL) { pval->type = MT_ERROR; @@ -229,7 +229,7 @@ mv_t s_f_sec2gmt_func(mv_t* pval1) { ERROR_OUT(*pval1); mt_get_double_nullable(pval1); NULL_OUT(*pval1); - if (pval1->type != MT_DOUBLE) + if (pval1->type != MT_FLOAT) return MV_ERROR; time_t clock = (time_t) pval1->u.fltv; struct tm tm; @@ -463,7 +463,7 @@ mv_t f_s_hms2fsec_func(mv_t* pval1) { } else { return MV_ERROR; } - return (mv_t) {.type = MT_DOUBLE, .u.fltv = sec * sign}; + return (mv_t) {.type = MT_FLOAT, .u.fltv = sec * sign}; } mv_t i_s_dhms2sec_func(mv_t* pval1) { @@ -510,7 +510,7 @@ mv_t f_s_dhms2fsec_func(mv_t* pval1) { } else { return MV_ERROR; } - return (mv_t) {.type = MT_DOUBLE, .u.fltv = sec * sign}; + return (mv_t) {.type = MT_FLOAT, .u.fltv = sec * sign}; } // ---------------------------------------------------------------- @@ -523,7 +523,7 @@ mv_t i_s_strlen_func(mv_t* pval1) { static mv_t int_i_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } static mv_t int_i_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } static mv_t int_i_b(mv_t* pa) { return (mv_t) {.type = MT_INT, .u.intv = pa->u.boolv ? 1 : 0}; } -static mv_t int_i_d(mv_t* pa) { return (mv_t) {.type = MT_INT, .u.intv = (long long)round(pa->u.fltv)}; } +static mv_t int_i_f(mv_t* pa) { return (mv_t) {.type = MT_INT, .u.intv = (long long)round(pa->u.fltv)}; } static mv_t int_i_i(mv_t* pa) { return (mv_t) {.type = MT_INT, .u.intv = pa->u.intv}; } static mv_t int_i_s(mv_t* pa) { mv_t retval = (mv_t) {.type = MT_INT }; @@ -538,7 +538,7 @@ static mv_unary_func_t* int_dispositions[MT_MAX] = { /*NULL*/ int_i_n, /*ERROR*/ int_i_e, /*BOOL*/ int_i_b, - /*DOUBLE*/ int_i_d, + /*FLOAT*/ int_i_f, /*INT*/ int_i_i, /*STRING*/ int_i_s, }; @@ -546,14 +546,13 @@ static mv_unary_func_t* int_dispositions[MT_MAX] = { mv_t i_x_int_func(mv_t* pval1) { return (int_dispositions[pval1->type])(pval1); } // ---------------------------------------------------------------- -// xxx i'm using double & long long but saying double & int. this is confusing & needs fixing. -static mv_t float_f_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } -static mv_t float_f_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } -static mv_t float_f_b(mv_t* pa) { return (mv_t) {.type = MT_DOUBLE, .u.fltv = pa->u.boolv ? 1.0 : 0.0}; } -static mv_t float_f_d(mv_t* pa) { return (mv_t) {.type = MT_DOUBLE, .u.fltv = pa->u.fltv}; } -static mv_t float_f_i(mv_t* pa) { return (mv_t) {.type = MT_DOUBLE, .u.fltv = pa->u.intv}; } +static mv_t float_f_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } +static mv_t float_f_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } +static mv_t float_f_b(mv_t* pa) { return (mv_t) {.type = MT_FLOAT, .u.fltv = pa->u.boolv ? 1.0 : 0.0}; } +static mv_t float_f_f(mv_t* pa) { return (mv_t) {.type = MT_FLOAT, .u.fltv = pa->u.fltv}; } +static mv_t float_f_i(mv_t* pa) { return (mv_t) {.type = MT_FLOAT, .u.fltv = pa->u.intv}; } static mv_t float_f_s(mv_t* pa) { - mv_t retval = (mv_t) {.type = MT_DOUBLE }; + mv_t retval = (mv_t) {.type = MT_FLOAT }; if (*pa->u.strv == '\0') return MV_NULL; if (!mlr_try_double_from_string(pa->u.strv, &retval.u.fltv)) @@ -565,7 +564,7 @@ static mv_unary_func_t* float_dispositions[MT_MAX] = { /*NULL*/ float_f_n, /*ERROR*/ float_f_e, /*BOOL*/ float_f_b, - /*DOUBLE*/ float_f_d, + /*FLOAT*/ float_f_f, /*INT*/ float_f_i, /*STRING*/ float_f_s, }; @@ -576,7 +575,7 @@ mv_t f_x_float_func(mv_t* pval1) { return (float_dispositions[pval1->type])(pval static mv_t boolean_b_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } static mv_t boolean_b_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } static mv_t boolean_b_b(mv_t* pa) { return (mv_t) {.type = MT_BOOL, .u.boolv = pa->u.boolv}; } -static mv_t boolean_b_d(mv_t* pa) { return (mv_t) {.type = MT_BOOL, .u.boolv = (pa->u.fltv == 0.0) ? FALSE : TRUE}; } +static mv_t boolean_b_f(mv_t* pa) { return (mv_t) {.type = MT_BOOL, .u.boolv = (pa->u.fltv == 0.0) ? FALSE : TRUE}; } static mv_t boolean_b_i(mv_t* pa) { return (mv_t) {.type = MT_BOOL, .u.boolv = (pa->u.intv == 0LL) ? FALSE : TRUE}; } static mv_t boolean_b_s(mv_t* pa) { return (mv_t) {.type = MT_BOOL, .u.boolv = (streq(pa->u.strv, "true") || streq(pa->u.strv, "TRUE")) ? TRUE : FALSE @@ -587,7 +586,7 @@ static mv_unary_func_t* boolean_dispositions[MT_MAX] = { /*NULL*/ boolean_b_n, /*ERROR*/ boolean_b_e, /*BOOL*/ boolean_b_b, - /*DOUBLE*/ boolean_b_d, + /*FLOAT*/ boolean_b_f, /*INT*/ boolean_b_i, /*STRING*/ boolean_b_s, }; @@ -598,7 +597,7 @@ mv_t b_x_boolean_func(mv_t* pval1) { return (boolean_dispositions[pval1->type])( static mv_t string_s_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } static mv_t string_s_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } static mv_t string_s_b(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_strdup_or_die(pa->u.boolv?"true":"false")}; } -static mv_t string_s_d(mv_t* pa) { +static mv_t string_s_f(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_alloc_string_from_double(pa->u.fltv, MLR_GLOBALS.ofmt)}; } static mv_t string_s_i(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_alloc_string_from_ll(pa->u.intv)}; } @@ -608,7 +607,7 @@ static mv_unary_func_t* string_dispositions[MT_MAX] = { /*NULL*/ string_s_n, /*ERROR*/ string_s_e, /*BOOL*/ string_s_b, - /*DOUBLE*/ string_s_d, + /*FLOAT*/ string_s_f, /*INT*/ string_s_i, /*STRING*/ string_s_s, }; @@ -619,7 +618,7 @@ mv_t s_x_string_func(mv_t* pval1) { return (string_dispositions[pval1->type])(pv static mv_t hexfmt_s_n(mv_t* pa) { return (mv_t) {.type = MT_NULL, .u.intv = 0}; } static mv_t hexfmt_s_e(mv_t* pa) { return (mv_t) {.type = MT_ERROR, .u.intv = 0}; } static mv_t hexfmt_s_b(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_strdup_or_die(pa->u.boolv?"0x1":"0x0")}; } -static mv_t hexfmt_s_d(mv_t* pa) { +static mv_t hexfmt_s_f(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_alloc_hexfmt_from_ll((long long)pa->u.fltv)}; } static mv_t hexfmt_s_i(mv_t* pa) { return (mv_t) {.type = MT_STRING, .u.strv = mlr_alloc_hexfmt_from_ll(pa->u.intv)}; } @@ -629,7 +628,7 @@ static mv_unary_func_t* hexfmt_dispositions[MT_MAX] = { /*NULL*/ hexfmt_s_n, /*ERROR*/ hexfmt_s_e, /*BOOL*/ hexfmt_s_b, - /*DOUBLE*/ hexfmt_s_d, + /*FLOAT*/ hexfmt_s_f, /*INT*/ hexfmt_s_i, /*STRING*/ hexfmt_s_s, }; @@ -652,7 +651,7 @@ static mv_binary_func_t* fmtnum_dispositions[MT_MAX] = { /*NULL*/ fmtnum_s_ns, /*ERROR*/ fmtnum_s_es, /*BOOL*/ fmtnum_s_bs, - /*DOUBLE*/ fmtnum_s_ds, + /*FLOAT*/ fmtnum_s_ds, /*INT*/ fmtnum_s_is, /*STRING*/ fmtnum_s_ss, }; @@ -773,61 +772,61 @@ static mv_t lt_b_ss(mv_t*pa, mv_t*pb) {return (mv_t){.type=MT_BOOL, .u.boolv=str static mv_t le_b_ss(mv_t*pa, mv_t*pb) {return (mv_t){.type=MT_BOOL, .u.boolv=strcmp(pa->u.strv, pb->u.strv) <= 0};} static mv_binary_func_t* eq_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, eq_b_ff, eq_b_fi, eq_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, eq_b_ff, eq_b_fi, eq_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, eq_b_if, eq_b_ii, eq_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, eq_b_sx, eq_b_sx, eq_b_ss}, }; static mv_binary_func_t* ne_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, ne_b_ff, ne_b_fi, ne_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, ne_b_ff, ne_b_fi, ne_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, ne_b_if, ne_b_ii, ne_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, ne_b_sx, ne_b_sx, ne_b_ss}, }; static mv_binary_func_t* gt_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, gt_b_ff, gt_b_fi, gt_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, gt_b_ff, gt_b_fi, gt_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, gt_b_if, gt_b_ii, gt_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, gt_b_sx, gt_b_sx, gt_b_ss}, }; static mv_binary_func_t* ge_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, ge_b_ff, ge_b_fi, ge_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, ge_b_ff, ge_b_fi, ge_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, ge_b_if, ge_b_ii, ge_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, ge_b_sx, ge_b_sx, ge_b_ss}, }; static mv_binary_func_t* lt_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, lt_b_ff, lt_b_fi, lt_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, lt_b_ff, lt_b_fi, lt_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, lt_b_if, lt_b_ii, lt_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, lt_b_sx, lt_b_sx, lt_b_ss}, }; static mv_binary_func_t* le_dispositions[MT_MAX][MT_MAX] = { - // NULL ERROR BOOL DOUBLE INT STRING + // NULL ERROR BOOL FLOAT INT STRING /*NULL*/ {op_n_xx, op_e_xx, op_e_xx, op_n_xx, op_n_xx, op_n_xx}, /*ERROR*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, /*BOOL*/ {op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx, op_e_xx}, - /*DOUBLE*/ {op_n_xx, op_e_xx, op_e_xx, le_b_ff, le_b_fi, le_b_xs}, + /*FLOAT*/ {op_n_xx, op_e_xx, op_e_xx, le_b_ff, le_b_fi, le_b_xs}, /*INT*/ {op_n_xx, op_e_xx, op_e_xx, le_b_if, le_b_ii, le_b_xs}, /*STRING*/ {op_n_xx, op_e_xx, op_e_xx, le_b_sx, le_b_sx, le_b_ss}, }; diff --git a/c/mapping/mlr_val.h b/c/mapping/mlr_val.h index f34b595b4..ac2aa2388 100644 --- a/c/mapping/mlr_val.h +++ b/c/mapping/mlr_val.h @@ -18,7 +18,7 @@ #define MT_NULL 0 // E.g. field name not present in input record -- not a problem. #define MT_ERROR 1 // E.g. error encountered in one eval & it propagates up the AST. #define MT_BOOL 2 -#define MT_DOUBLE 3 +#define MT_FLOAT 3 #define MT_INT 4 #define MT_STRING 5 #define MT_MAX 6 @@ -87,43 +87,43 @@ static inline mv_t b_bb_and_func(mv_t* pval1, mv_t* pval2) { // ---------------------------------------------------------------- static inline mv_t f_z_urand_func() { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = get_mtrand_double()}; // mtrand.h + mv_t rv = {.type = MT_FLOAT, .u.fltv = get_mtrand_double()}; // mtrand.h return rv; } static inline mv_t f_z_systime_func() { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = get_systime()}; // mlrutil.h + mv_t rv = {.type = MT_FLOAT, .u.fltv = get_systime()}; // mlrutil.h return rv; } // ---------------------------------------------------------------- -static inline mv_t f_f_abs_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=fabs(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_acos_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=acos(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_acosh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=acosh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_asin_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=asin(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_asinh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=asinh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_atan_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=atan(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_atanh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=atanh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_cbrt_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=cbrt(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_ceil_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=ceil(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_cos_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=cos(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_cosh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=cosh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_erf_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=erf(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_erfc_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=erfc(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_exp_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=exp(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_expm1_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=expm1(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_floor_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=floor(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_invqnorm_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=invqnorm(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_log10_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=log10(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_log1p_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=log1p(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_log_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=log(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_qnorm_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=qnorm(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_round_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=round(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_sin_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=sin(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_sinh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=sinh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_sqrt_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=sqrt(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_tan_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=tan(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_tanh_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=tanh(pval1->u.fltv)}; return rv;} -static inline mv_t f_f_uneg_func(mv_t* pval1){mv_t rv={.type=MT_DOUBLE,.u.fltv=-pval1->u.fltv}; return rv;} +static inline mv_t f_f_abs_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=fabs(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_acos_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=acos(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_acosh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=acosh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_asin_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=asin(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_asinh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=asinh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_atan_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=atan(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_atanh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=atanh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_cbrt_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=cbrt(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_ceil_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=ceil(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_cos_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=cos(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_cosh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=cosh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_erf_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=erf(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_erfc_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=erfc(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_exp_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=exp(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_expm1_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=expm1(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_floor_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=floor(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_invqnorm_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=invqnorm(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_log10_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=log10(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_log1p_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=log1p(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_log_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=log(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_qnorm_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=qnorm(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_round_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=round(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_sin_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=sin(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_sinh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=sinh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_sqrt_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=sqrt(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_tan_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=tan(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_tanh_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=tanh(pval1->u.fltv)}; return rv;} +static inline mv_t f_f_uneg_func(mv_t* pval1){mv_t rv={.type=MT_FLOAT,.u.fltv=-pval1->u.fltv}; return rv;} mv_t i_x_int_func(mv_t* pval1); mv_t f_x_float_func(mv_t* pval1); @@ -134,19 +134,19 @@ mv_t s_xs_fmtnum_func(mv_t* pval1, mv_t* pval2); // ---------------------------------------------------------------- static inline mv_t f_ff_plus_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = pval1->u.fltv + pval2->u.fltv}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = pval1->u.fltv + pval2->u.fltv}; return rv; } static inline mv_t f_ff_minus_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = pval1->u.fltv - pval2->u.fltv}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = pval1->u.fltv - pval2->u.fltv}; return rv; } static inline mv_t f_ff_times_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = pval1->u.fltv * pval2->u.fltv}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = pval1->u.fltv * pval2->u.fltv}; return rv; } static inline mv_t f_ff_divide_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = pval1->u.fltv / pval2->u.fltv}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = pval1->u.fltv / pval2->u.fltv}; return rv; } static inline mv_t f_ff_max_func(mv_t* pval1, mv_t* pval2) { @@ -155,7 +155,7 @@ static inline mv_t f_ff_max_func(mv_t* pval1, mv_t* pval2) { } else if (pval2->type == MT_NULL) { return *pval1; } else { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = fmax(pval1->u.fltv, pval2->u.fltv)}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = fmax(pval1->u.fltv, pval2->u.fltv)}; return rv; } } @@ -165,12 +165,12 @@ static inline mv_t f_ff_min_func(mv_t* pval1, mv_t* pval2) { } else if (pval2->type == MT_NULL) { return *pval1; } else { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = fmin(pval1->u.fltv, pval2->u.fltv)}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = fmin(pval1->u.fltv, pval2->u.fltv)}; return rv; } } static inline mv_t f_ff_pow_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = pow(pval1->u.fltv, pval2->u.fltv)}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = pow(pval1->u.fltv, pval2->u.fltv)}; return rv; } static inline mv_t f_ff_mod_func(mv_t* pval1, mv_t* pval2) { @@ -179,19 +179,19 @@ static inline mv_t f_ff_mod_func(mv_t* pval1, mv_t* pval2) { long long i3 = i1 % i2; if (i3 < 0) i3 += i2; // C mod is insane - mv_t rv = {.type = MT_DOUBLE, .u.fltv = (double)i3}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = (double)i3}; return rv; } static inline mv_t f_ff_atan2_func(mv_t* pval1, mv_t* pval2) { - mv_t rv = {.type = MT_DOUBLE, .u.fltv = atan2(pval1->u.fltv, pval2->u.fltv)}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = atan2(pval1->u.fltv, pval2->u.fltv)}; return rv; } static inline mv_t f_ff_roundm_func(mv_t* pval1, mv_t* pval2) { double x = pval1->u.fltv; double m = pval2->u.fltv; - mv_t rv = {.type = MT_DOUBLE, .u.fltv = round(x / m) * m}; + mv_t rv = {.type = MT_FLOAT, .u.fltv = round(x / m) * m}; return rv; }