work toward distribution functions

diff --git a/doc/matrices.texi b/doc/matrices.texi
index cceff9b997a4bc8b89551ff861ee31db057f830f..5b3ff9a9eacdf5f81f3821e0c8b1630b88b40e24 100644 (file)
--- a/doc/matrices.texi
+++ b/doc/matrices.texi
@@ -2351,7 +2351,7 @@ can be useful to write more than one matrix on a single output line.
 This matrix program:
 
 @example
-WRITE {1, 2; 3, 4} /OUTFILE='matrix.txt' /FIELD=1 TO 80.
+WRITE @{1, 2; 3, 4@} /OUTFILE='matrix.txt' /FIELD=1 TO 80.
 @end example
 
 @noindent
@@ -2372,12 +2372,14 @@ WRITE MAGIC(5) /OUTFILE='matrix.txt' /FIELD=1 TO 80 BY 5 /MODE=TRIANGULAR.
 
 @noindent
 writes the following to @file{matrix.txt}:
+
+@example
     17
     23    5
      4    6   13
     10   12   19   21
     11   18   25    2    9
-@example
+@end example
 
 @node Matrix GET Command
 @subsection The @code{GET} Command

diff --git a/src/language/stats/matrix.c b/src/language/stats/matrix.c
index e7d3ae8e27f380facbf3a0105d029b287a940fb4..a33e7693cd55dfb9558345ba6b33ddb1e603b1d7 100644 (file)
--- a/src/language/stats/matrix.c
+++ b/src/language/stats/matrix.c
@@ -177,61 +177,61 @@ matrix_var_set (struct matrix_var *var, gsl_matrix *value)
   var->value = value;
 }
 \f
-#define MATRIX_FUNCTIONS \
-    F(ABS, m_m) \
-    F(ALL, d_m) \
-    F(ANY, d_m) \
-    F(ARSIN, m_m) \
-    F(ARTAN, m_m) \
-    F(BLOCK, m_any) \
-    F(CHOL, m_m) \
-    F(CMIN, m_m) \
-    F(CMAX, m_m) \
-    F(COS, m_m) \
-    F(CSSQ, m_m) \
-    F(CSUM, m_m) \
-    F(DESIGN, m_m) \
-    F(DET, d_m) \
-    F(DIAG, m_m) \
-    F(EVAL, m_m) \
-    F(EXP, m_m) \
-    F(GINV, m_m) \
-    F(GRADE, m_m) \
-    F(GSCH, m_m) \
-    F(IDENT, IDENT) \
-    F(INV, m_m) \
-    F(KRONEKER, m_mm) \
-    F(LG10, m_m) \
-    F(LN, m_m) \
-    F(MAGIC, m_d) \
-    F(MAKE, m_ddd) \
-    F(MDIAG, m_v) \
-    F(MMAX, d_m) \
-    F(MMIN, d_m) \
-    F(MOD, m_md) \
-    F(MSSQ, d_m) \
-    F(MSUM, d_m) \
-    F(NCOL, d_m) \
-    F(NROW, d_m) \
-    F(RANK, d_m) \
-    F(RESHAPE, m_mdd) \
-    F(RMAX, m_m) \
-    F(RMIN, m_m) \
-    F(RND, m_m) \
-    F(RNKORDER, m_m) \
-    F(RSSQ, m_m) \
-    F(RSUM, m_m) \
-    F(SIN, m_m) \
-    F(SOLVE, m_mm) \
-    F(SQRT, m_m) \
-    F(SSCP, m_m) \
-    F(SVAL, m_m) \
-    F(SWEEP, m_md) \
-    F(T, m_m) \
-    F(TRACE, d_m) \
-    F(TRANSPOS, m_m) \
-    F(TRUNC, m_m) \
-    F(UNIFORM, m_dd)
+#define MATRIX_FUNCTIONS                        \
+    F(ABS,      "ABS",      m_m)                \
+    F(ALL,      "ALL",      d_m)                \
+    F(ANY,      "ANY",      d_m)                \
+    F(ARSIN,    "ARSIN",    m_m)                \
+    F(ARTAN,    "ARTAN",    m_m)                \
+    F(BLOCK,    "BLOCK",    m_any)              \
+    F(CHOL,     "CHOL",     m_m)                \
+    F(CMIN,     "CMIN",     m_m)                \
+    F(CMAX,     "CMAX",     m_m)                \
+    F(COS,      "COS",      m_m)                \
+    F(CSSQ,     "CSSQ",     m_m)                \
+    F(CSUM,     "CSUM",     m_m)                \
+    F(DESIGN,   "DESIGN",   m_m)                \
+    F(DET,      "DET",      d_m)                \
+    F(DIAG,     "DIAG",     m_m)                \
+    F(EVAL,     "EVAL",     m_m)                \
+    F(EXP,      "EXP",      m_m)                \
+    F(GINV,     "GINV",     m_m)                \
+    F(GRADE,    "GRADE",    m_m)                \
+    F(GSCH,     "GSCH",     m_m)                \
+    F(IDENT,    "IDENT",    IDENT)              \
+    F(INV,      "INV",      m_m)                \
+    F(KRONEKER, "KRONEKER", m_mm)               \
+    F(LG10,     "LG10",     m_m)                \
+    F(LN,       "LN",       m_m)                \
+    F(MAGIC,    "MAGIC",    m_d)                \
+    F(MAKE,     "MAKE",     m_ddd)              \
+    F(MDIAG,    "MDIAG",    m_v)                \
+    F(MMAX,     "MMAX",     d_m)                \
+    F(MMIN,     "MMIN",     d_m)                \
+    F(MOD,      "MOD",      m_md)               \
+    F(MSSQ,     "MSSQ",     d_m)                \
+    F(MSUM,     "MSUM",     d_m)                \
+    F(NCOL,     "NCOL",     d_m)                \
+    F(NROW,     "NROW",     d_m)                \
+    F(RANK,     "RANK",     d_m)                \
+    F(RESHAPE,  "RESHAPE",  m_mdd)              \
+    F(RMAX,     "RMAX",     m_m)                \
+    F(RMIN,     "RMIN",     m_m)                \
+    F(RND,      "RND",      m_m)                \
+    F(RNKORDER, "RNKORDER", m_m)                \
+    F(RSSQ,     "RSSQ",     m_m)                \
+    F(RSUM,     "RSUM",     m_m)                \
+    F(SIN,      "SIN",      m_m)                \
+    F(SOLVE,    "SOLVE",    m_mm)               \
+    F(SQRT,     "SQRT",     m_m)                \
+    F(SSCP,     "SSCP",     m_m)                \
+    F(SVAL,     "SVAL",     m_m)                \
+    F(SWEEP,    "SWEEP",    m_md)               \
+    F(T,        "T",        m_m)                \
+    F(TRACE,    "TRACE",    d_m)                \
+    F(TRANSPOS, "TRANSPOS", m_m)                \
+    F(TRUNC,    "TRUNC",    m_m)                \
+    F(UNIFORM,  "UNIFORM",  m_dd)
 
 enum { m_d_MIN_ARGS = 1, m_d_MAX_ARGS = 1 };
 enum { m_dd_MIN_ARGS = 2, m_dd_MAX_ARGS = 2 };
@@ -257,7 +257,7 @@ typedef double matrix_proto_d_m (gsl_matrix *);
 typedef gsl_matrix *matrix_proto_m_any (gsl_matrix *[], size_t n);
 typedef gsl_matrix *matrix_proto_IDENT (double, double);
 
-#define F(NAME, PROTOTYPE) static matrix_proto_##PROTOTYPE matrix_eval_##NAME;
+#define F(ENUM, STRING, PROTO) static matrix_proto_##PROTO matrix_eval_##ENUM;
 MATRIX_FUNCTIONS
 #undef F
 \f
@@ -268,7 +268,7 @@ struct matrix_expr
     enum matrix_op
       {
         /* Functions. */
-#define F(NAME, PROTOTYPE) MOP_F_##NAME,
+#define F(ENUM, STRING, PROTO) MOP_F_##ENUM,
         MATRIX_FUNCTIONS
 #undef F
 
@@ -343,7 +343,7 @@ matrix_expr_destroy (struct matrix_expr *e)
 
   switch (e->op)
     {
-#define F(NAME, PROTOTYPE) case MOP_F_##NAME:
+#define F(ENUM, STRING, PROTO) case MOP_F_##ENUM:
 MATRIX_FUNCTIONS
 #undef F
     case MOP_NEGATE:
@@ -1671,7 +1671,8 @@ matrix_parse_function_name (const char *token)
 {
   static const struct matrix_function functions[] =
     {
-#define F(NAME, PROTO) { #NAME, MOP_F_##NAME, PROTO##_MIN_ARGS, PROTO##_MAX_ARGS },
+#define F(ENUM, STRING, PROTO) \
+      { #ENUM, MOP_F_##ENUM, PROTO##_MIN_ARGS, PROTO##_MAX_ARGS },
       MATRIX_FUNCTIONS
 #undef F
     };
@@ -2216,7 +2217,7 @@ matrix_op_eval (enum matrix_op op, double a, double b)
     case MOP_OR: return (a > 0) || (b > 0);
     case MOP_XOR: return (a > 0) != (b > 0);
 
-#define F(NAME, PROTOTYPE) case MOP_F_##NAME:
+#define F(ENUM, STRING, PROTO) case MOP_F_##ENUM:
       MATRIX_FUNCTIONS
 #undef F
     case MOP_NEGATE:
@@ -2261,7 +2262,7 @@ matrix_op_name (enum matrix_op op)
     case MOP_OR: return "OR";
     case MOP_XOR: return "XOR";
 
-#define F(NAME, PROTOTYPE) case MOP_F_##NAME:
+#define F(ENUM, STRING, PROTO) case MOP_F_##ENUM:
       MATRIX_FUNCTIONS
 #undef F
     case MOP_NEGATE:
@@ -2719,10 +2720,10 @@ matrix_expr_evaluate_mat_index (gsl_matrix *sm, gsl_matrix *im0,
   return dm;
 }
 
-#define F(NAME, PROTOTYPE)                              \
-  static gsl_matrix *matrix_expr_evaluate_##PROTOTYPE ( \
+#define F(ENUM, STRING, PROTO)                          \
+  static gsl_matrix *matrix_expr_evaluate_##PROTO (     \
     const char *name, gsl_matrix *[], size_t,           \
-    matrix_proto_##PROTOTYPE *);
+    matrix_proto_##PROTO *);
 MATRIX_FUNCTIONS
 #undef F
 
@@ -2936,11 +2937,10 @@ matrix_expr_evaluate (const struct matrix_expr *e)
   gsl_matrix *result = NULL;
   switch (e->op)
     {
-#define F(NAME, PROTOTYPE)                                              \
-      case MOP_F_##NAME:                                                \
-        result = matrix_expr_evaluate_##PROTOTYPE (#NAME,               \
-                                                   subs, e->n_subs,     \
-                                                   matrix_eval_##NAME); \
+#define F(ENUM, STRING, PROTO)                                          \
+      case MOP_F_##ENUM:                                                \
+        result = matrix_expr_evaluate_##PROTO (STRING, subs, e->n_subs, \
+                                               matrix_eval_##ENUM);     \
       break;
       MATRIX_FUNCTIONS
 #undef F