// -*- c -*-
//
-// PSPP - computes sample statistics.
-// Copyright (C) 2005, 2006 Free Software Foundation, Inc.
+// 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 2 of the
-// License, or (at your option) any later version.
+// 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.
+// 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, write to the Free Software
-// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-// 02110-1301, USA. */
+// 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.;
}
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;
}
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;
}
{
struct substring *w = &a[2 * i];
struct substring *y = &a[2 * i + 1];
- if (compare_string (w, &x) <= 0 && compare_string (&x, y) <= 0)
+ 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.YEAR (date >= DAY_S) = calendar_offset_to_year (date / DAY_S);
// Date arithmetic functions.
-no_abbrev function DATEDIFF (date1 >= DAY_S, date2 >= DAY_S, string unit)
+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"));
function NUMBER (string s, ni_format f)
{
union value out;
- data_in (ss_head (s, f->w), f->type, f->d, 0, &out, 0);
+ 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;
}
{
union value v;
struct substring dst;
+ char *s;
v.f = x;
- dst = alloc_string (e, f->w);
+
assert (!fmt_is_string (f->type));
- data_out (&v, f, dst.string);
+ s = data_out (&v, LEGACY_NATIVE, f);
+ dst = alloc_string (e, strlen (s));
+ strcpy (dst.string, s);
+ free (s);
return dst;
}
// 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);
{
const struct variable *var = vector_get_var (v, (size_t) idx - 1);
double value = case_num (c, var);
- return !var_is_num_user_missing (var, value) ? value : SYSMIS;
+ return !var_is_num_missing (var, value, MV_USER) ? value : SYSMIS;
}
else
{
if (idx >= 1 && idx <= vector_get_var_cnt (v))
{
struct variable *var = vector_get_var (v, (size_t) idx - 1);
- return copy_string (e, case_str (c, var), var_get_width (var));
+ return copy_string (e, CHAR_CAST_BUG (char *, case_str (c, var)),
+ var_get_width (var));
}
else
{
num_var v;
{
double d = case_num (c, v);
- return !var_is_num_user_missing (v, d) ? d : SYSMIS;
+ return !var_is_num_missing (v, d, MV_USER) ? d : SYSMIS;
}
no_opt string operator STR_VAR ()
no_opt perm_only function LAG (num_var v, pos_int n_before)
dataset ds;
{
- struct ccase *c = lagged_case (ds, n_before);
+ const struct ccase *c = lagged_case (ds, n_before);
if (c != NULL)
{
double x = case_num (c, v);
- return !var_is_num_user_missing (v, x) ? x : SYSMIS;
+ 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 (ds, 1);
+ const struct ccase *c = lagged_case (ds, 1);
if (c != NULL)
{
double x = case_num (c, v);
- return !var_is_num_user_missing (v, x) ? x : SYSMIS;
+ return !var_is_num_missing (v, x, MV_USER) ? x : SYSMIS;
}
else
return SYSMIS;
expression e;
dataset ds;
{
- struct ccase *c = lagged_case (ds, n_before);
+ const struct ccase *c = lagged_case (ds, n_before);
if (c != NULL)
- return copy_string (e, case_str (c, v), var_get_width (v));
+ return copy_string (e, CHAR_CAST_BUG (char *, case_str (c, v)),
+ var_get_width (v));
else
return empty_string;
}
expression e;
dataset ds;
{
- struct ccase *c = lagged_case (ds, 1);
+ const struct ccase *c = lagged_case (ds, 1);
if (c != NULL)
- return copy_string (e, case_str (c, v), var_get_width (v));
+ return copy_string (e, CHAR_CAST_BUG (char *, case_str (c, v)),
+ var_get_width (v));
else
return empty_string;
}
projects / pspp-builds.git / blobdiff