X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Fexpressions%2Foperations.def;h=db71d2770339db273fa5114fe456afb83f106411;hb=f15c854d8500105766b2f5666bb62b983ff24f88;hp=fe3bc5de2fe88f357baee3e00d259eab152eb120;hpb=b74d09af5e07f954c18e7cdb8aca3af47fa10208;p=pspp-builds.git diff --git a/src/language/expressions/operations.def b/src/language/expressions/operations.def index fe3bc5de..db71d277 100644 --- a/src/language/expressions/operations.def +++ b/src/language/expressions/operations.def @@ -1,4 +1,20 @@ // -*- c -*- +// +// PSPP - a program for statistical analysis. +// Copyright (C) 2005, 2006, 2009 Free Software Foundation, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . operator NEG (x) = -x; @@ -299,6 +315,15 @@ function XDATE.WEEK (date >= DAY_S) function XDATE.WKDAY (date >= DAY_S) = calendar_offset_to_wday (date / DAY_S); function XDATE.YEAR (date >= DAY_S) = calendar_offset_to_year (date / DAY_S); +// Date arithmetic functions. +no_abbrev function DATEDIFF (date2 >= DAY_S, date1 >= DAY_S, string unit) + = expr_date_difference (date1, date2, unit); +no_abbrev function DATESUM (date, quantity, string unit) + = expr_date_sum (date, quantity, unit, ss_cstr ("closest")); +no_abbrev function DATESUM (date, quantity, string unit, string method) + = expr_date_sum (date, quantity, unit, method); + + // String functions. string function CONCAT (string a[n]) expression e; @@ -547,15 +572,8 @@ string function RTRIM (string s, string c) function NUMBER (string s, ni_format f) { - struct data_in di; union value out; - di.s = s.string; - di.v = &out; - di.flags = DI_IMPLIED_DECIMALS; - di.f1 = 1; - di.format = *f; - di.e = s.string + min (s.length, di.format.w); - data_in (&di); + data_in (ss_head (s, f->w), LEGACY_NATIVE, f->type, f->d, 0, 0, &out, 0); return out.f; } @@ -564,11 +582,15 @@ absorb_miss string function STRING (x, no_format f) { union value v; struct substring dst; + char *s; v.f = x; - dst = alloc_string (e, f->w); - assert ((formats[f->type].cat & FCAT_STRING) == 0); - data_out (dst.string, f, &v); + + assert (!fmt_is_string (f->type)); + s = data_out (&v, f); + dst = alloc_string (e, strlen (s)); + strcpy (dst.string, s); + free (s); return dst; } @@ -595,6 +617,17 @@ absorb_miss string function SUBSTR (string s, ofs, cnt) return empty_string; } +absorb_miss no_opt no_abbrev string function VALUELABEL (var v) + expression e; + case c; +{ + const char *label = var_lookup_value_label (v, case_data (c, v)); + if (label != NULL) + return copy_string (e, label, strlen (label)); + else + return empty_string; +} + // Artificial. operator SQUARE (x) = x * x; boolean operator NUM_TO_BOOLEAN (x) @@ -618,7 +651,7 @@ function PDF.BETA (x >= 0 && x <= 1, a > 0, b > 0) = gsl_ran_beta_pdf (x, a, b); function CDF.BETA (x >= 0 && x <= 1, a > 0, b > 0) = gsl_cdf_beta_P (x, a, b); function IDF.BETA (P >= 0 && P <= 1, a > 0, b > 0) - = gslextras_cdf_beta_Pinv (P, a, b); + = gsl_cdf_beta_Pinv (P, a, b); no_opt function RV.BETA (a > 0, b > 0) = gsl_ran_beta (get_rng (), a, b); function NCDF.BETA (x >= 0, a > 0, b > 0, lambda > 0) = ncdf_beta (x, a, b, lambda); @@ -821,7 +854,7 @@ no_opt function RV.BERNOULLI (p >= 0 && p <= 1) // Binomial distribution. function CDF.BINOM (k, n > 0 && n == floor (n), p >= 0 && p <= 1) - = gslextras_cdf_binomial_P (k, p, n); + = gsl_cdf_binomial_P (k, p, n); function PDF.BINOM (k >= 0 && k == floor (k) && k <= n, n > 0 && n == floor (n), p >= 0 && p <= 1) @@ -831,7 +864,7 @@ no_opt function RV.BINOM (p > 0 && p == floor (p), n >= 0 && n <= 1) // Geometric distribution. function CDF.GEOM (k >= 1 && k == floor (k), p >= 0 && p <= 1) - = gslextras_cdf_geometric_P (k, p); + = gsl_cdf_geometric_P (k, p); function PDF.GEOM (k >= 1 && k == floor (k), p >= 0 && p <= 1) = gsl_ran_geometric_pdf (k, p); @@ -842,7 +875,7 @@ function CDF.HYPER (k >= 0 && k == floor (k) && k <= c, a > 0 && a == floor (a), b > 0 && b == floor (b) && b <= a, c > 0 && c == floor (c) && c <= a) - = gslextras_cdf_hypergeometric_P (k, c, a - c, b); + = gsl_cdf_hypergeometric_P (k, c, a - c, b); function PDF.HYPER (k >= 0 && k == floor (k) && k <= c, a > 0 && a == floor (a), b > 0 && b == floor (b) && b <= a, @@ -861,7 +894,7 @@ no_opt extension function RV.LOG (p > 0 && p <= 1) // Negative binomial distribution. function CDF.NEGBIN (k >= 1, n == floor (n), p > 0 && p <= 1) - = gslextras_cdf_negative_binomial_P (k, p, n); + = gsl_cdf_negative_binomial_P (k, p, n); function PDF.NEGBIN (k >= 1, n == floor (n), p > 0 && p <= 1) = gsl_ran_negative_binomial_pdf (k, p, n); no_opt function RV.NEGBIN (n == floor (n), p > 0 && p <= 1) @@ -869,7 +902,7 @@ no_opt function RV.NEGBIN (n == floor (n), p > 0 && p <= 1) // Poisson distribution. function CDF.POISSON (k >= 0 && k == floor (k), mu > 0) - = gslextras_cdf_poisson_P (k, mu); + = gsl_cdf_poisson_P (k, mu); function PDF.POISSON (k >= 0 && k == floor (k), mu > 0) = gsl_ran_poisson_pdf (k, mu); no_opt function RV.POISSON (mu > 0) = gsl_ran_poisson (get_rng (), mu); @@ -880,34 +913,34 @@ absorb_miss boolean function SYSMIS (x) = x == SYSMIS || !finite (x); no_opt boolean function SYSMIS (num_var v) case c; { - return case_num (c, v->fv) == SYSMIS; + return case_num (c, v) == SYSMIS; } no_opt boolean function VALUE (num_var v) case c; { - return case_num (c, v->fv); + return case_num (c, v); } no_opt operator VEC_ELEM_NUM (idx) vector v; case c; { - if (idx >= 1 && idx <= v->cnt) + if (idx >= 1 && idx <= vector_get_var_cnt (v)) { - const struct variable *var = v->var[(int) idx - 1]; - double value = case_num (c, var->fv); - return !mv_is_num_user_missing (&var->miss, value) ? value : SYSMIS; + const struct variable *var = vector_get_var (v, (size_t) idx - 1); + double value = case_num (c, var); + return !var_is_num_missing (var, value, MV_USER) ? value : SYSMIS; } else { if (idx == SYSMIS) msg (SE, _("SYSMIS is not a valid index value for vector " "%s. The result will be set to SYSMIS."), - v->name); + vector_get_name (v)); else msg (SE, _("%g is not a valid index value for vector %s. " "The result will be set to SYSMIS."), - idx, v->name); + idx, vector_get_name (v)); return SYSMIS; } } @@ -917,21 +950,21 @@ absorb_miss no_opt string operator VEC_ELEM_STR (idx) vector v; case c; { - if (idx >= 1 && idx <= v->cnt) + if (idx >= 1 && idx <= vector_get_var_cnt (v)) { - struct variable *var = v->var[(int) idx - 1]; - return copy_string (e, case_str (c, var->fv), var->width); + struct variable *var = vector_get_var (v, (size_t) idx - 1); + return copy_string (e, case_str (c, var), var_get_width (var)); } else { if (idx == SYSMIS) msg (SE, _("SYSMIS is not a valid index value for vector " "%s. The result will be set to the empty string."), - v->name); + vector_get_name (v)); else msg (SE, _("%g is not a valid index value for vector %s. " "The result will be set to the empty string."), - idx, v->name); + idx, vector_get_name (v)); return empty_string; } } @@ -942,8 +975,8 @@ no_opt operator NUM_VAR () case c; num_var v; { - double d = case_num (c, v->fv); - return !mv_is_num_user_missing (&v->miss, d) ? d : SYSMIS; + double d = case_num (c, v); + return !var_is_num_missing (v, d, MV_USER) ? d : SYSMIS; } no_opt string operator STR_VAR () @@ -951,30 +984,32 @@ no_opt string operator STR_VAR () expression e; str_var v; { - struct substring s = alloc_string (e, v->width); - memcpy (s.string, case_str (c, v->fv), v->width); + struct substring s = alloc_string (e, var_get_width (v)); + memcpy (s.string, case_str (c, v), var_get_width (v)); return s; } no_opt perm_only function LAG (num_var v, pos_int n_before) + dataset ds; { - struct ccase *c = lagged_case (n_before); + const struct ccase *c = lagged_case (ds, n_before); if (c != NULL) { - double x = case_num (c, v->fv); - return !mv_is_num_user_missing (&v->miss, x) ? x : SYSMIS; + double x = case_num (c, v); + return !var_is_num_missing (v, x, MV_USER) ? x : SYSMIS; } else return SYSMIS; } no_opt perm_only function LAG (num_var v) + dataset ds; { - struct ccase *c = lagged_case (1); + const struct ccase *c = lagged_case (ds, 1); if (c != NULL) { - double x = case_num (c, v->fv); - return !mv_is_num_user_missing (&v->miss, x) ? x : SYSMIS; + double x = case_num (c, v); + return !var_is_num_missing (v, x, MV_USER) ? x : SYSMIS; } else return SYSMIS; @@ -982,20 +1017,22 @@ no_opt perm_only function LAG (num_var v) no_opt perm_only string function LAG (str_var v, pos_int n_before) expression e; + dataset ds; { - struct ccase *c = lagged_case (n_before); + const struct ccase *c = lagged_case (ds, n_before); if (c != NULL) - return copy_string (e, case_str (c, v->fv), v->width); + return copy_string (e, case_str (c, v), var_get_width (v)); else return empty_string; } no_opt perm_only string function LAG (str_var v) expression e; + dataset ds; { - struct ccase *c = lagged_case (1); + const struct ccase *c = lagged_case (ds, 1); if (c != NULL) - return copy_string (e, case_str (c, v->fv), v->width); + return copy_string (e, case_str (c, v), var_get_width (v)); else return empty_string; } @@ -1004,14 +1041,14 @@ no_opt operator NUM_SYS () case c; num_var v; { - return case_num (c, v->fv) == SYSMIS; + return case_num (c, v) == SYSMIS; } no_opt operator NUM_VAL () case c; num_var v; { - return case_num (c, v->fv); + return case_num (c, v); } no_opt operator CASENUM ()