// -*- 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 <http://www.gnu.org/licenses/>.
operator NEG (x) = -x;
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;
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;
}
{
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;
}
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)
= 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);
// 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)
// 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);
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,
// 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)
// 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);
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;
}
}
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;
}
}
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 ()
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 (current_dataset, 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 (current_dataset, 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;
no_opt perm_only string function LAG (str_var v, pos_int n_before)
expression e;
+ dataset ds;
{
- struct ccase *c = lagged_case (current_dataset, 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 (current_dataset, 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;
}
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 ()
projects / pspp-builds.git / blobdiff