return m;
}
+/* Inverts X, storing the inverse into INVERSE. As a side effect, replaces X
+ by its LU decomposition. */
static void
-invert_matrix (gsl_matrix *x)
+invert_matrix (gsl_matrix *x, gsl_matrix *inverse)
{
gsl_permutation *p = gsl_permutation_alloc (x->size1);
int signum;
gsl_linalg_LU_decomp (x, p, &signum);
- gsl_linalg_LU_invx (x, p);
+ gsl_linalg_LU_invert (x, p, inverse);
gsl_permutation_free (p);
}
static gsl_matrix *
-matrix_eval_INV (gsl_matrix *m)
+matrix_eval_INV (gsl_matrix *src)
{
- invert_matrix (m);
- return m;
+ gsl_matrix *dst = gsl_matrix_alloc (src->size1, src->size2);
+ invert_matrix (src, dst);
+ return dst;
}
static gsl_matrix *
if (bf != floor (bf) || bf <= LONG_MIN || bf > LONG_MAX)
{
msg_at (SE, matrix_expr_location (e->subs[1]),
- _("Exponent %.1f in matrix multiplication is non-integer "
+ _("Exponent %.1f in matrix exponentiation is non-integer "
"or outside the valid range."), bf);
return NULL;
}
mul_matrix (&y, x, y, &t);
if (bf < 0)
- invert_matrix (y);
+ {
+ invert_matrix (y, x);
+ swap_matrix (&x, &y);
+ }
/* Garbage collection.
if (lex_token (s->lexer) != T_SLASH && lex_token (s->lexer) != T_ENDCMD)
{
- size_t depth = 0;
- for (size_t i = 0; ; i++)
- {
- enum token_type t = lex_next_token (s->lexer, i);
- if (t == T_LPAREN || t == T_LBRACK || t == T_LCURLY)
- depth++;
- else if ((t == T_RPAREN || t == T_RBRACK || t == T_RCURLY) && depth)
- depth--;
- else if ((t == T_SLASH && !depth) || t == T_ENDCMD || t == T_STOP)
- {
- if (i > 0)
- cmd->print.title = lex_next_representation (s->lexer, 0, i - 1);
- break;
- }
- }
-
+ int start_ofs = lex_ofs (s->lexer);
cmd->print.expression = matrix_parse_exp (s);
if (!cmd->print.expression)
goto error;
+ cmd->print.title = lex_ofs_representation (s->lexer, start_ofs,
+ lex_ofs (s->lexer) - 1);
}
while (lex_match (s->lexer, T_SLASH))
struct stringi_set strings;
stringi_set_clone (&strings, &sf->strings);
- for (size_t i = 0; dict_get_var_cnt (dict) < m->size2; i++)
+ for (size_t i = 0; dict_get_n_vars (dict) < m->size2; i++)
{
char tmp_name[64];
const char *name;
{
char s[FMT_STRING_LEN_MAX + 1];
fmt_to_string (write->format, s);
- msg (SE, _("Format %s is too wide for %zu-byte matrix eleemnts."),
+ msg (SE, _("Format %s is too wide for %zu-byte matrix elements."),
s, sizeof (double));
goto error;
}
}
else
{
- n_vars = dict_get_var_cnt (dict);
+ n_vars = dict_get_n_vars (dict);
vars = xnmalloc (n_vars, sizeof *vars);
for (size_t i = 0; i < n_vars; i++)
{
error = true;
}
}
- else if (var_is_num_missing (var, d, MV_USER))
+ else if (var_is_num_missing (var, d) == MV_USER)
{
if (get->user.treatment == MGET_RECODE)
d = get->user.substitute;
}
else
{
- if (dict_get_var_cnt (dataset_dict (dataset)) == 0)
+ if (dict_get_n_vars (dataset_dict (dataset)) == 0)
{
msg_at (ME, cmd->location,
_("The %s command cannot read an empty active file."),
{
struct variable *var = dict_get_var (d, cs + x);
double value = case_num (rows[y], var);
- if (var_is_num_missing (var, value, MV_ANY))
+ if (var_is_num_missing (var, value))
{
n_missing++;
value = 0.0;
_("ROWTYPE_ must precede VARNAME_ in matrix data file."));
return;
}
- if (var_get_dict_index (varname_) + 1 >= dict_get_var_cnt (d))
+ if (var_get_dict_index (varname_) + 1 >= dict_get_n_vars (d))
{
msg_at (SE, loc, _("Matrix data file contains no continuous variables."));
return;
}
- for (size_t i = 0; i < dict_get_var_cnt (d); i++)
+ for (size_t i = 0; i < dict_get_n_vars (d); i++)
{
const struct variable *v = dict_get_var (d, i);
if (v != rowtype_ && v != varname_ && var_get_width (v) != 0)
/* Continuous variables. */
size_t cs = var_get_dict_index (varname_) + 1;
- size_t cn = dict_get_var_cnt (d) - cs;
+ size_t cn = dict_get_n_vars (d) - cs;
struct ccase *cc = NULL;
/* Pivot table. */