Mirrors/miller
1
0
Fork 0
mirror of https://github.com/johnkerl/miller.git synced 2026-07-24 00:18:39 +00:00
Code Issues Projects Releases Wiki Activity

neaten

Browse source
This commit is contained in:
John Kerl 2015-10-02 21:26:48 -04:00
parent e497e374c0
commit 2a488e7803
3 changed files with 100 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

40
c/mapping/lrec_evaluators.c
View file

@ -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);

79
c/mapping/mlr_val.c
View file

@ -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},
};

82
c/mapping/mlr_val.h
View file

@ -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;
}