The R Project SVN R

Rev

Rev 20701 | Rev 31569 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 r 1 
/*
465 maechler 2 
 *  R : A Computer Language for Statistical Data Analysis
8552 maechler 3 
 *  Copyright (C) 1995, 1996	Robert Gentleman and Ross Ihaka
20701 ripley 4 
 *  Copyright (C) 2000--2002	The R Development Core Team.
2 r 5 
 *
6 
 *  This program is free software; you can redistribute it and/or modify
7 
 *  it under the terms of the GNU General Public License as published by
8 
 *  the Free Software Foundation; either version 2 of the License, or
9 
 *  (at your option) any later version.
10 
 *
11 
 *  This program is distributed in the hope that it will be useful,
12 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 
 *  GNU General Public License for more details.
15 
 *
16 
 *  You should have received a copy of the GNU General Public License
17 
 *  along with this program; if not, write to the Free Software
5458 ripley 18 
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
1895 ihaka 19 
 *
20 
 *
21 
 *  EXPORTS	printMatrix()
4717 maechler 22 
 *		printArray()
1754 pd 23 
 *
1895 ihaka 24 
 *  See ./printutils.c	 for general remarks on Printing
4717 maechler 25 
 *			 and the Encode.. utils.
1895 ihaka 26 
 *
27 
 *  See ./format.c	 for the  format_FOO_  functions used below.
2 r 28 
 */
1895 ihaka 29 
 
4710 pd 30 
 
5187 hornik 31 
#ifdef HAVE_CONFIG_H
7701 hornik 32 
#include <config.h>
5187 hornik 33 
#endif
34 
 
2 r 35 
#include "Defn.h"
36 
#include "Print.h"
37 
 
1858 ihaka 38 
static void printLogicalMatrix(SEXP sx, int offset, int r, int c,
4710 pd 39 
			       SEXP rl, SEXP cl, char *rn, char *cn)
2 r 40 
{
1820 ihaka 41 
    SEXP sw;
42 
    int *x, *w;
4731 pd 43 
    int width, rlabw, clabw, rnw;
4710 pd 44 
    int i, j, jmin, jmax, lbloff = 0;
2 r 45 
 
1895 ihaka 46 
    if (!isNull(rl))
10172 luke 47 
	formatString(STRING_PTR(rl), r, &rlabw, 0);
1895 ihaka 48 
    else
49 
	rlabw = IndexWidth(r + 1) + 3;
4731 pd 50 
 
51 
    if (rn) {
52 
	rnw = strlen(rn);
8552 maechler 53 
	if ( rnw < rlabw + R_MIN_LBLOFF )
54 
	    lbloff = R_MIN_LBLOFF;
4731 pd 55 
	else
56 
	    lbloff = rnw - rlabw;
57 
 
58 
	rlabw += lbloff;
59 
    }
60 
 
1820 ihaka 61 
    sw = allocVector(INTSXP, c);
1858 ihaka 62 
    x = INTEGER(sx) + offset;
1820 ihaka 63 
    w = INTEGER(sw);
2 r 64 
 
1858 ihaka 65 
    for (j = 0; j < c; j++) {
1820 ihaka 66 
	formatLogical(&x[j * r], r, &w[j]);
20701 ripley 67 
	if (!isNull(cl)) {
68 
	    if(STRING_ELT(cl, j) == NA_STRING)
69 
		clabw = R_print.na_width_noquote;
70 
	    else clabw = strlen(CHAR(STRING_ELT(cl, j)));
71 
	} else
1895 ihaka 72 
	    clabw = IndexWidth(j + 1) + 3;
73 
	if (w[j] < clabw)
74 
	    w[j] = clabw;
4619 maechler 75 
	w[j] += R_print.gap;
1820 ihaka 76 
    }
77 
    jmin = 0;
78 
    jmax = 0;
20812 ripley 79 
    if (c == 0) {
80 
	for (i = 0; i < r; i++)
81 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
82 
	Rprintf("\n");
83 
	return;
84 
    }
1858 ihaka 85 
    while (jmin < c) {
1820 ihaka 86 
	width = rlabw;
87 
	do {
88 
	    width += w[jmax];
89 
	    jmax++;
2 r 90 
	}
4619 maechler 91 
	while (jmax < c && width + w[jmax] < R_print.width);
4731 pd 92 
 
93 
	if (cn != NULL)
94 
	    Rprintf("%*s%s\n", rlabw, "", cn);
95 
 
96 
	if (rn != NULL)
97 
	    Rprintf("%*s", -rlabw, rn);
98 
	else
99 
	    Rprintf("%*s", rlabw, "");
100 
 
1858 ihaka 101 
	for (j = jmin; j < jmax ; j++)
1820 ihaka 102 
	    MatrixColumnLabel(cl, j, w[j]);
103 
	for (i = 0; i < r; i++) {
4710 pd 104 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
1820 ihaka 105 
	    for (j = jmin; j < jmax; j++) {
1858 ihaka 106 
		Rprintf("%s", EncodeLogical(x[i + j * r], w[j]));
1820 ihaka 107 
	    }
2 r 108 
	}
1820 ihaka 109 
	Rprintf("\n");
110 
	jmin = jmax;
111 
    }
2 r 112 
}
113 
 
1858 ihaka 114 
static void printIntegerMatrix(SEXP sx, int offset, int r, int c,
4710 pd 115 
			       SEXP rl, SEXP cl, char *rn, char *cn)
2 r 116 
{
1820 ihaka 117 
    SEXP sw;
118 
    int *x, *w;
4710 pd 119 
    int width, rlabw, clabw, rnw;
120 
    int i, j, jmin, jmax, lbloff = 0;
2 r 121 
 
1895 ihaka 122 
    if (!isNull(rl))
10172 luke 123 
	formatString(STRING_PTR(rl), r, &rlabw, 0);
1895 ihaka 124 
    else
125 
	rlabw = IndexWidth(r + 1) + 3;
4717 maechler 126 
 
4710 pd 127 
    if (rn) {
4717 maechler 128 
	rnw = strlen(rn);
8552 maechler 129 
	if ( rnw < rlabw + R_MIN_LBLOFF )
130 
	    lbloff = R_MIN_LBLOFF;
4710 pd 131 
	else
4711 pd 132 
	    lbloff = rnw - rlabw;
133 
 
134 
	rlabw += lbloff;
4710 pd 135 
    }
136 
 
1820 ihaka 137 
    sw = allocVector(INTSXP, c);
1858 ihaka 138 
    x = INTEGER(sx) + offset;
1820 ihaka 139 
    w = INTEGER(sw);
1858 ihaka 140 
    for (j = 0; j < c; j++) {
1820 ihaka 141 
	formatInteger(&x[j * r], r, &w[j]);
20701 ripley 142 
	if (!isNull(cl)) {
143 
	    if(STRING_ELT(cl, j) == NA_STRING)
144 
		clabw = R_print.na_width_noquote;
145 
	    else clabw = strlen(CHAR(STRING_ELT(cl, j)));
146 
	} else
1895 ihaka 147 
	    clabw = IndexWidth(j + 1) + 3;
148 
	if (w[j] < clabw)
149 
	    w[j] = clabw;
4619 maechler 150 
	w[j] += R_print.gap;
1820 ihaka 151 
    }
152 
    jmin = 0;
153 
    jmax = 0;
20812 ripley 154 
    if (c == 0) {
155 
	for (i = 0; i < r; i++)
156 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
157 
	Rprintf("\n");
158 
	return;
159 
    }
1858 ihaka 160 
    while (jmin < c) {
1820 ihaka 161 
	width = rlabw;
162 
	do {
163 
	    width += w[jmax];
164 
	    jmax++;
1858 ihaka 165 
	}
4619 maechler 166 
	while (jmax < c && width + w[jmax] < R_print.width);
4710 pd 167 
 
168 
	if (cn != NULL)
169 
	    Rprintf("%*s%s\n", rlabw, "", cn);
170 
 
171 
	if (rn != NULL)
172 
	    Rprintf("%*s", -rlabw, rn);
173 
	else
174 
	    Rprintf("%*s", rlabw, "");
175 
 
1858 ihaka 176 
	for (j = jmin; j < jmax ; j++)
1820 ihaka 177 
	    MatrixColumnLabel(cl, j, w[j]);
178 
	for (i = 0; i < r; i++) {
4710 pd 179 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
1820 ihaka 180 
	    for (j = jmin; j < jmax; j++) {
1858 ihaka 181 
		Rprintf("%s", EncodeInteger(x[i + j * r], w[j]));
1820 ihaka 182 
	    }
2 r 183 
	}
1820 ihaka 184 
	Rprintf("\n");
185 
	jmin = jmax;
186 
    }
2 r 187 
}
188 
 
1858 ihaka 189 
static void printRealMatrix(SEXP sx, int offset, int r, int c,
4710 pd 190 
			    SEXP rl, SEXP cl, char *rn, char *cn)
2 r 191 
{
1820 ihaka 192 
    SEXP sd, se, sw;
193 
    double *x;
194 
    int *d, *e, *w;
4731 pd 195 
    int width, rlabw, clabw, rnw;
4710 pd 196 
    int i, j, jmin, jmax, lbloff = 0;
2 r 197 
 
1895 ihaka 198 
    if (!isNull(rl))
10172 luke 199 
	formatString(STRING_PTR(rl), r, &rlabw, 0);
1895 ihaka 200 
    else
201 
	rlabw = IndexWidth(r + 1) + 3;
4731 pd 202 
 
203 
    if (rn) {
204 
	rnw = strlen(rn);
8552 maechler 205 
	if ( rnw < rlabw + R_MIN_LBLOFF )
206 
	    lbloff = R_MIN_LBLOFF;
4731 pd 207 
	else
208 
	    lbloff = rnw - rlabw;
209 
 
210 
	rlabw += lbloff;
211 
    }
212 
 
1820 ihaka 213 
    PROTECT(sd = allocVector(INTSXP, c));
214 
    PROTECT(se = allocVector(INTSXP, c));
215 
    sw = allocVector(INTSXP, c);
216 
    UNPROTECT(2);
1858 ihaka 217 
    x = REAL(sx) + offset;
1820 ihaka 218 
    d = INTEGER(sd);
219 
    e = INTEGER(se);
220 
    w = INTEGER(sw);
2 r 221 
 
1858 ihaka 222 
    for (j = 0; j < c; j++) {
14357 ripley 223 
	formatReal(&x[j * r], r, &w[j], &d[j], &e[j], 0);
20701 ripley 224 
	if (!isNull(cl)) {
225 
	    if(STRING_ELT(cl, j) == NA_STRING)
226 
		clabw = R_print.na_width_noquote;
227 
	    else clabw = strlen(CHAR(STRING_ELT(cl, j)));
228 
	} else
1895 ihaka 229 
	    clabw = IndexWidth(j + 1) + 3;
230 
	if (w[j] < clabw)
231 
	    w[j] = clabw;
4619 maechler 232 
	w[j] += R_print.gap;
1820 ihaka 233 
    }
234 
    jmin = 0;
235 
    jmax = 0;
20812 ripley 236 
    if (c == 0) {
237 
	for (i = 0; i < r; i++)
238 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
239 
	Rprintf("\n");
240 
	return;
241 
    }
1858 ihaka 242 
    while (jmin < c) {
1820 ihaka 243 
	width = rlabw;
244 
	do {
245 
	    width += w[jmax];
246 
	    jmax++;
1858 ihaka 247 
	}
4619 maechler 248 
	while (jmax < c && width + w[jmax] < R_print.width);
4731 pd 249 
 
250 
	if (cn != NULL)
251 
	    Rprintf("%*s%s\n", rlabw, "", cn);
252 
 
253 
	if (rn != NULL)
254 
	    Rprintf("%*s", -rlabw, rn);
255 
	else
256 
	    Rprintf("%*s", rlabw, "");
257 
 
1858 ihaka 258 
	for (j = jmin; j < jmax ; j++)
1820 ihaka 259 
	    MatrixColumnLabel(cl, j, w[j]);
260 
	for (i = 0; i < r; i++) {
4710 pd 261 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
1820 ihaka 262 
	    for (j = jmin; j < jmax; j++) {
1858 ihaka 263 
		Rprintf("%s", EncodeReal(x[i + j * r], w[j], d[j], e[j]));
1820 ihaka 264 
	    }
2 r 265 
	}
1820 ihaka 266 
	Rprintf("\n");
267 
	jmin = jmax;
268 
    }
2 r 269 
}
270 
 
1858 ihaka 271 
static void printComplexMatrix(SEXP sx, int offset, int r, int c,
4710 pd 272 
			       SEXP rl, SEXP cl, char *rn, char *cn)
2 r 273 
{
580 ihaka 274 
    SEXP sdr, ser, swr, sdi, sei, swi, sw;
6994 pd 275 
    Rcomplex *x;
580 ihaka 276 
    int *dr, *er, *wr, *di, *ei, *wi, *w;
4731 pd 277 
    int width, rlabw, clabw, rnw;
4710 pd 278 
    int i, j, jmin, jmax, lbloff = 0;
2 r 279 
 
1895 ihaka 280 
    if (!isNull(rl))
10172 luke 281 
	formatString(STRING_PTR(rl), r, &rlabw, 0);
1895 ihaka 282 
    else
283 
	rlabw = IndexWidth(r + 1) + 3;
4731 pd 284 
 
285 
    if (rn) {
286 
	rnw = strlen(rn);
8552 maechler 287 
	if ( rnw < rlabw + R_MIN_LBLOFF )
288 
	    lbloff = R_MIN_LBLOFF;
4731 pd 289 
	else
290 
	    lbloff = rnw - rlabw;
291 
 
292 
	rlabw += lbloff;
293 
    }
294 
 
580 ihaka 295 
    PROTECT(sdr = allocVector(INTSXP, c));
296 
    PROTECT(ser = allocVector(INTSXP, c));
297 
    PROTECT(swr = allocVector(INTSXP, c));
298 
    PROTECT(sdi = allocVector(INTSXP, c));
299 
    PROTECT(sei = allocVector(INTSXP, c));
300 
    PROTECT(swi = allocVector(INTSXP, c));
5055 pd 301 
    PROTECT(sw  = allocVector(INTSXP, c));
580 ihaka 302 
    UNPROTECT(7);
1858 ihaka 303 
    x = COMPLEX(sx) + offset;
580 ihaka 304 
    dr = INTEGER(sdr);
305 
    er = INTEGER(ser);
306 
    wr = INTEGER(swr);
307 
    di = INTEGER(sdi);
308 
    ei = INTEGER(sei);
309 
    wi = INTEGER(swi);
310 
    w = INTEGER(sw);
2 r 311 
 
580 ihaka 312 
    /* Determine the column widths */
2 r 313 
 
1858 ihaka 314 
    for (j = 0; j < c; j++) {
8552 maechler 315 
	formatComplex(&x[j * r], r,
4928 maechler 316 
		      &wr[j], &dr[j], &er[j],
14357 ripley 317 
		      &wi[j], &di[j], &ei[j], 0);
20701 ripley 318 
	if (!isNull(cl)) {
319 
	    if(STRING_ELT(cl, j) == NA_STRING)
320 
		clabw = R_print.na_width_noquote;
321 
	    else clabw = strlen(CHAR(STRING_ELT(cl, j)));
322 
	} else
1895 ihaka 323 
	    clabw = IndexWidth(j + 1) + 3;
580 ihaka 324 
	w[j] = wr[j] + wi[j] + 2;
1895 ihaka 325 
	if (w[j] < clabw)
326 
	    w[j] = clabw;
4619 maechler 327 
	w[j] += R_print.gap;
580 ihaka 328 
    }
2 r 329 
 
580 ihaka 330 
    jmin = 0;
331 
    jmax = 0;
20812 ripley 332 
    if (c == 0) {
333 
	for (i = 0; i < r; i++)
334 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
335 
	Rprintf("\n");
336 
	return;
337 
    }
1858 ihaka 338 
    while (jmin < c) {
580 ihaka 339 
	width = rlabw;
340 
	do {
341 
	    width += w[jmax];
342 
	    jmax++;
1858 ihaka 343 
	}
4619 maechler 344 
	while (jmax < c && width+w[jmax] < R_print.width);
4731 pd 345 
 
346 
	if (cn != NULL)
347 
	    Rprintf("%*s%s\n", rlabw, "", cn);
348 
 
349 
	if (rn != NULL)
350 
	    Rprintf("%*s", -rlabw, rn);
351 
	else
352 
	    Rprintf("%*s", rlabw, "");
353 
 
1858 ihaka 354 
	for (j = jmin; j < jmax ; j++)
580 ihaka 355 
	    MatrixColumnLabel(cl, j, w[j]);
356 
	for (i = 0; i < r; i++) {
4710 pd 357 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
1858 ihaka 358 
	    for (j = jmin; j < jmax; j++) {
359 
		if (ISNA(x[i + j * r].r) || ISNA(x[i + j * r].i))
580 ihaka 360 
		    Rprintf("%s", EncodeReal(NA_REAL, w[j], 0, 0));
361 
		else
8552 maechler 362 
		    Rprintf("%s",
5055 pd 363 
			    EncodeComplex(x[i + j * r],
364 
					  wr[j] + R_print.gap, dr[j], er[j],
365 
					  wi[j], di[j], ei[j]));
580 ihaka 366 
	    }
2 r 367 
	}
580 ihaka 368 
	Rprintf("\n");
369 
	jmin = jmax;
370 
    }
2 r 371 
}
372 
 
1858 ihaka 373 
static void printStringMatrix(SEXP sx, int offset, int r, int c,
4717 maechler 374 
			      int quote, int right, SEXP rl, SEXP cl,
375 
			      char *rn, char *cn)
2 r 376 
{
1820 ihaka 377 
    SEXP sw;
378 
    SEXP *x;
379 
    int *w;
4731 pd 380 
    int width, rlabw, clabw, rnw;
4710 pd 381 
    int i, j, jmin, jmax, lbloff = 0;
2 r 382 
 
1895 ihaka 383 
    if (!isNull(rl))
10172 luke 384 
	formatString(STRING_PTR(rl), r, &rlabw, 0);
1895 ihaka 385 
    else
386 
	rlabw = IndexWidth(r + 1) + 3;
4731 pd 387 
 
388 
    if (rn) {
389 
	rnw = strlen(rn);
8552 maechler 390 
	if ( rnw < rlabw + R_MIN_LBLOFF )
391 
	    lbloff = R_MIN_LBLOFF;
4731 pd 392 
	else
393 
	    lbloff = rnw - rlabw;
394 
 
395 
	rlabw += lbloff;
396 
    }
397 
 
1820 ihaka 398 
    sw = allocVector(INTSXP, c);
10172 luke 399 
    x = STRING_PTR(sx)+offset;
1820 ihaka 400 
    w = INTEGER(sw);
1858 ihaka 401 
    for (j = 0; j < c; j++) {
1820 ihaka 402 
	formatString(&x[j * r], r, &w[j], quote);
20701 ripley 403 
	if (!isNull(cl)) {
404 
	    if(STRING_ELT(cl, j) == NA_STRING)
405 
		clabw = R_print.na_width_noquote;
406 
	    else clabw = strlen(CHAR(STRING_ELT(cl, j)));
407 
	} else
408 
	    clabw = IndexWidth(j + 1) + 3;
1895 ihaka 409 
	if (w[j] < clabw)
410 
	    w[j] = clabw;
1820 ihaka 411 
    }
412 
    jmin = 0;
413 
    jmax = 0;
20812 ripley 414 
    if (c == 0) {
415 
	for (i = 0; i < r; i++)
416 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
417 
	Rprintf("\n");
418 
	return;
419 
    }
1858 ihaka 420 
    while (jmin < c) {
1820 ihaka 421 
	width = rlabw;
422 
	do {
4619 maechler 423 
	    width += w[jmax] + R_print.gap;
1820 ihaka 424 
	    jmax++;
1858 ihaka 425 
	}
4619 maechler 426 
	while (jmax < c && width + w[jmax] + R_print.gap < R_print.width);
4731 pd 427 
 
428 
	if (cn != NULL)
429 
	    Rprintf("%*s%s\n", rlabw, "", cn);
430 
 
431 
	if (rn != NULL)
432 
	    Rprintf("%*s", -rlabw, rn);
433 
	else
434 
	    Rprintf("%*s", rlabw, "");
435 
 
1820 ihaka 436 
	if (right) {
1858 ihaka 437 
	    for (j = jmin; j < jmax ; j++)
1820 ihaka 438 
		RightMatrixColumnLabel(cl, j, w[j]);
2 r 439 
	}
1820 ihaka 440 
	else {
1858 ihaka 441 
	    for (j = jmin; j < jmax ; j++)
1820 ihaka 442 
		LeftMatrixColumnLabel(cl, j, w[j]);
443 
	}
444 
	for (i = 0; i < r; i++) {
4710 pd 445 
	    MatrixRowLabel(rl, i, rlabw, lbloff);
1820 ihaka 446 
	    for (j = jmin; j < jmax; j++) {
4619 maechler 447 
		Rprintf("%*s%s", R_print.gap, "",
1858 ihaka 448 
			EncodeString(CHAR(x[i + j * r]), w[j], quote, right));
1820 ihaka 449 
	    }
450 
	}
451 
	Rprintf("\n");
452 
	jmin = jmax;
453 
    }
2 r 454 
}
455 
 
1858 ihaka 456 
void printMatrix(SEXP x, int offset, SEXP dim, int quote, int right,
4710 pd 457 
		 SEXP rl, SEXP cl, char *rn, char *cn)
2 r 458 
{
1820 ihaka 459 
    int r, c;
2 r 460 
 
1820 ihaka 461 
    r = INTEGER(dim)[0];
462 
    c = INTEGER(dim)[1];
12976 pd 463 
    /* PR#850 */
464 
    if ((rl!=R_NilValue) && (r>length(rl)))
465 
	error("too few row labels");
466 
    if ((cl!=R_NilValue) && (c>length(cl)))
467 
	error("too few column labels");
20812 ripley 468 
    if (r == 0 && c == 0) {
469 
	Rprintf("<0 x 0 matrix>\n");
470 
	return;
471 
    }
1820 ihaka 472 
    switch (TYPEOF(x)) {
473 
    case LGLSXP:
4710 pd 474 
	printLogicalMatrix(x, offset, r, c, rl, cl, rn, cn);
1820 ihaka 475 
	break;
476 
    case INTSXP:
4710 pd 477 
	printIntegerMatrix(x, offset, r, c, rl, cl, rn, cn);
1820 ihaka 478 
	break;
479 
    case REALSXP:
4710 pd 480 
	printRealMatrix(x, offset, r, c, rl, cl, rn, cn);
1820 ihaka 481 
	break;
482 
    case CPLXSXP:
4710 pd 483 
	printComplexMatrix(x, offset, r, c, rl, cl, rn, cn);
1820 ihaka 484 
	break;
485 
    case STRSXP:
486 
	if (quote) quote = '"';
4710 pd 487 
	printStringMatrix(x, offset, r, c, quote, right, rl, cl, rn, cn);
1820 ihaka 488 
	break;
489 
    }
490 
}
491 
 
1858 ihaka 492 
static void printArrayGeneral(SEXP x, SEXP dim, int quote, SEXP dimnames)
1820 ihaka 493 
{
3076 pd 494 
/* == printArray(.) */
12976 pd 495 
    SEXP dn, dnn;
1820 ihaka 496 
    int i, j, k, l, b, nb, ndim;
497 
    int nr, nc;
4710 pd 498 
    int has_dimnames = 0, has_dnn = 0;
4711 pd 499 
    char *rn = NULL, *cn = NULL;
1820 ihaka 500 
 
501 
    ndim = LENGTH(dim);
502 
    if (ndim == 1)
503 
	printVector(x, 1, quote);
504 
    else if (ndim == 2) {
505 
	SEXP rl, cl;
4710 pd 506 
	GetMatrixDimnames(x, &rl, &cl, &rn, &cn);
507 
	printMatrix(x, 0, dim, quote, 0, rl, cl, rn, cn);
1820 ihaka 508 
    }
509 
    else {
510 
	SEXP dn0, dn1;
511 
	nr = INTEGER(dim)[0];
512 
	nc = INTEGER(dim)[1];
513 
	b = nr * nc;
514 
	nb = 1;
515 
	for (i = 2 ; i < ndim ; i++)
516 
	    nb *= INTEGER(dim)[i];
4790 hornik 517 
	dnn = R_NilValue;	/* -Wall */
1858 ihaka 518 
	if (dimnames == R_NilValue) {
519 
	    dn0 = R_NilValue;
520 
	    dn1 = R_NilValue;
521 
	}
522 
	else {
10172 luke 523 
	    dn0 = VECTOR_ELT(dimnames, 0);
524 
	    dn1 = VECTOR_ELT(dimnames, 1);
2462 hornik 525 
	    has_dimnames = 1;
4710 pd 526 
	    dnn = getAttrib(dimnames, R_NamesSymbol);
4717 maechler 527 
	    has_dnn = !isNull(dnn);
4710 pd 528 
	    if ( has_dnn ) {
10172 luke 529 
		rn = CHAR(STRING_ELT(dnn, 0));
530 
		cn = CHAR(STRING_ELT(dnn, 1));
4710 pd 531 
	    }
1858 ihaka 532 
	}
1820 ihaka 533 
	for (i = 0; i < nb; i++) {
534 
	    Rprintf(", ");
535 
	    k = 1;
1858 ihaka 536 
	    for (j = 2 ; j < ndim; j++) {
1820 ihaka 537 
		l = (i / k) % INTEGER(dim)[j] + 1;
2462 hornik 538 
		if (has_dimnames &&
10172 luke 539 
		    ((dn = VECTOR_ELT(dimnames, j)) != R_NilValue)) {
4710 pd 540 
		    if ( has_dnn )
4717 maechler 541 
			Rprintf(", %s = %s",
10172 luke 542 
				CHAR(STRING_ELT(dnn, j)),
543 
				CHAR(STRING_ELT(dn, l - 1)));
4710 pd 544 
		    else
10172 luke 545 
			Rprintf(", %s", CHAR(STRING_ELT(dn, l - 1)));
4717 maechler 546 
		} else
1820 ihaka 547 
		    Rprintf(", %d", l);
548 
		k = k * INTEGER(dim)[j];
549 
	    }
2254 pd 550 
	    Rprintf("\n\n");
1820 ihaka 551 
	    switch (TYPEOF(x)) {
552 
	    case LGLSXP:
4710 pd 553 
		printLogicalMatrix(x, i * b, nr, nc, dn0, dn1, rn, cn);
2 r 554 
		break;
1820 ihaka 555 
	    case INTSXP:
4710 pd 556 
		printIntegerMatrix(x, i * b, nr, nc, dn0, dn1, rn, cn);
2 r 557 
		break;
1820 ihaka 558 
	    case REALSXP:
4710 pd 559 
		printRealMatrix(x, i * b, nr, nc, dn0, dn1, rn, cn);
2 r 560 
		break;
1820 ihaka 561 
	    case CPLXSXP:
4710 pd 562 
		printComplexMatrix(x, i * b, nr, nc, dn0, dn1, rn, cn);
2 r 563 
		break;
1820 ihaka 564 
	    case STRSXP:
2 r 565 
		if (quote) quote = '"';
4710 pd 566 
		printStringMatrix(x, i * b, nr, nc, quote, 0, dn0, dn1, rn, cn);
2 r 567 
		break;
1820 ihaka 568 
	    }
569 
	    Rprintf("\n");
2 r 570 
	}
1820 ihaka 571 
    }
2 r 572 
}
573 
 
1858 ihaka 574 
void printArray(SEXP x, SEXP dim, int quote, SEXP dimnames)
2 r 575 
{
1895 ihaka 576 
    printArrayGeneral(x, dim, quote, dimnames);
2 r 577 
}