// -*- c -*-
+//
+// PSPP - a program for statistical analysis.
+// Copyright (C) 2005, 2006, 2009, 2010, 2011 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;
boolean operator NE (a, b) = a != b;
// String relational operators.
-boolean operator EQ_STRING (string a, string b) = compare_string (&a, &b) == 0;
-boolean operator GE_STRING (string a, string b) = compare_string (&a, &b) >= 0;
-boolean operator GT_STRING (string a, string b) = compare_string (&a, &b) > 0;
-boolean operator LE_STRING (string a, string b) = compare_string (&a, &b) <= 0;
-boolean operator LT_STRING (string a, string b) = compare_string (&a, &b) < 0;
-boolean operator NE_STRING (string a, string b) = compare_string (&a, &b) != 0;
+boolean operator EQ_STRING (string a, string b) = compare_string_3way (&a, &b) == 0;
+boolean operator GE_STRING (string a, string b) = compare_string_3way (&a, &b) >= 0;
+boolean operator GT_STRING (string a, string b) = compare_string_3way (&a, &b) > 0;
+boolean operator LE_STRING (string a, string b) = compare_string_3way (&a, &b) <= 0;
+boolean operator LT_STRING (string a, string b) = compare_string_3way (&a, &b) < 0;
+boolean operator NE_STRING (string a, string b) = compare_string_3way (&a, &b) != 0;
// Unary functions.
function ABS (x) = fabs (x);
size_t i;
for (i = 0; i < n; i++)
- if (!compare_string (&x, &a[i]))
+ if (!compare_string_3way (&x, &a[i]))
return 1.;
return 0.;
}
string function MAX (string a[n])
{
- struct fixed_string *max;
+ struct substring *max;
size_t i;
max = &a[0];
for (i = 1; i < n; i++)
- if (compare_string (&a[i], max) > 0)
+ if (compare_string_3way (&a[i], max) > 0)
max = &a[i];
return *max;
}
string function MIN (string a[n])
{
- struct fixed_string *min;
+ struct substring *min;
size_t i;
min = &a[0];
for (i = 1; i < n; i++)
- if (compare_string (&a[i], min) < 0)
+ if (compare_string_3way (&a[i], min) < 0)
min = &a[i];
return *min;
}
for (i = 0; i < n; i++)
{
- struct fixed_string *w = &a[2 * i];
- struct fixed_string *y = &a[2 * i + 1];
- if (compare_string (w, &x) <= 0 && compare_string (&x, y) <= 0)
+ struct substring *w = &a[2 * i];
+ struct substring *y = &a[2 * i + 1];
+ if (compare_string_3way (w, &x) <= 0 && compare_string_3way (&x, y) <= 0)
return 1.;
}
return 0.;
function DATE.DMY (d, m, y) = expr_ymd_to_date (y, m, d);
function DATE.MDY (m, d, y) = expr_ymd_to_date (y, m, d);
function DATE.MOYR (m, y) = expr_ymd_to_date (y, m, 1);
-function DATE.QYR (q, y) = expr_ymd_to_date (y, q * 3 - 2, 1);
+function DATE.QYR (q, y)
+{
+ if (q < 1.0 || q > 4.0 || q != (int) q)
+ {
+ msg (SW, _("The first argument to DATE.QYR must be 1, 2, 3, or 4."));
+ return SYSMIS;
+ }
+ return expr_ymd_to_date (y, q * 3 - 2, 1);
+}
function DATE.WKYR (w, y) = expr_wkyr_to_date (w, y);
function DATE.YRDAY (y, yday) = expr_yrday_to_date (y, yday);
function YRMODA (y, m, d) = expr_yrmoda (y, m, d);
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;
{
- struct fixed_string dst;
+ struct substring dst;
size_t i;
dst = alloc_string (e, MAX_STRING);
dst.length = 0;
for (i = 0; i < n; i++)
{
- struct fixed_string *src = &a[i];
+ struct substring *src = &a[i];
size_t copy_len;
copy_len = src->length;
return s;
else
{
- struct fixed_string t = alloc_string (e, n);
+ struct substring t = alloc_string (e, n);
memset (t.string, ' ', n - s.length);
memcpy (&t.string[(int) n - s.length], s.string, s.length);
return t;
return s;
else
{
- struct fixed_string t = alloc_string (e, n);
+ struct substring t = alloc_string (e, n);
memset (t.string, c.string[0], n - s.length);
memcpy (&t.string[(int) n - s.length], s.string, s.length);
return t;
return s;
else
{
- struct fixed_string t = alloc_string (e, n);
+ struct substring t = alloc_string (e, n);
memcpy (t.string, s.string, s.length);
memset (&t.string[s.length], ' ', n - s.length);
return t;
return s;
else
{
- struct fixed_string t = alloc_string (e, n);
+ struct substring t = alloc_string (e, n);
memcpy (t.string, s.string, s.length);
memset (&t.string[s.length], c.string[0], n - s.length);
return t;
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);
+ char *error;
+
+ if (s.length > f->w)
+ s.length = f->w;
+ error = data_in (s, LEGACY_NATIVE, f->type, &out, 0, NULL);
+ if (error == NULL)
+ data_in_imply_decimals (s, LEGACY_NATIVE, f->type, f->d, &out);
+ else
+ {
+ msg (SE, "Cannot parse `%.*s' as format %s: %s",
+ (int) s.length, s.string, fmt_name (f->type), error);
+ free (error);
+ }
return out.f;
}
expression e;
{
union value v;
- struct fixed_string dst;
+ 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, LEGACY_NATIVE, 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)
+boolean operator NUM_TO_BOOLEAN (x, string op_name)
{
if (x == 0. || x == 1. || x == SYSMIS)
return x;
else
{
- msg (SE, _("A number being treated as a Boolean in an "
- "expression was found to have a value other than "
- "0 (false), 1 (true), or the system-missing value. "
- "The result was forced to 0."));
+ msg (SE, _("An operand of the %.*s operator was found to have a value "
+ "other than 0 (false), 1 (true), or the system-missing "
+ "value. The result was forced to 0."),
+ (int) op_name.length, op_name.string);
return 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);
// 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, CHAR_CAST_BUG (char *, 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 fixed_string 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;
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, CHAR_CAST_BUG (char *, 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, CHAR_CAST_BUG (char *, 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