R: Default Printing

print.default {base} | R Documentation

## Default Printing

### Description

`print.default` is the default method of the generic `print` function which prints its argument.

### Usage

    ## Default S3 method:
    print(x, digits = NULL, quote = TRUE,
          na.print = NULL, print.gap = NULL, right = FALSE,
          max = NULL, useSource = TRUE, ...)

### Arguments

`x` | the object to be printed.
`digits` | a non-null value for `digits` specifies the minimum number of significant digits to be printed in values. The default, `NULL`, uses `getOption(digits)`. (For the interpretation for complex numbers see `signif`.) Non-integer values will be rounded down, and only values greater than or equal to 1 and no greater than 22 are accepted.
`quote` | logical, indicating whether or not strings (`character`s) should be printed with surrounding quotes.
`na.print` | a character string which is used to indicate `NA` values in printed output, or `NULL` (see ‘Details’).
`print.gap` | a non-negative integer ≤ 1024, or `NULL` (meaning 1), giving the spacing between adjacent columns in printed vectors, matrices and arrays.
`right` | logical, indicating whether or not strings should be right aligned. The default is left alignment.
`max` | a non-null value for `max` specifies the approximate maximum number of entries to be printed. The default, `NULL`, uses `getOption(max.print)`; see that help page for more details.
`useSource` | logical, indicating whether to use source references or copies rather than deparsing language objects. The default is to use the original source if it is available.
`...` | further arguments to be passed to or from other methods. They are ignored in this function.

### Details

The default for printing `NA`s is to print `NA` (without quotes) unless this is a character `NA` and `quote = FALSE`, when <NA> is printed.

The same number of decimal places is used throughout a vector. This means that `digits` specifies the minimum number of significant digits to be used, and that at least one entry will be encoded with that minimum number. However, if all the encoded elements then have trailing zeroes, the number of decimal places is reduced until at least one element has a non-zero final digit. Decimal points are only included if at least one decimal place is selected.

Attributes are printed respecting their class(es), using the values of `digits` to `print.default`, but using the default values (for the methods called) of the other arguments.

When the methods package is attached, `print` will call `show` for R objects with formal classes if called with no optional arguments.

### Large number of digits

Note that for large values of `digits`, currently for `digits >= 16`, the calculation of the number of significant digits will depend on the platform's internal (C library) implementation of sprintf() functionality.

### Single-byte locales

If a non-printable character is encountered during output, it is represented as one of the ANSI escape sequences (\a, \b, \f, \n, \r, \t, \v, \\ and \0: see Quotes), or failing that as a 3-digit octal code: for example the UK currency pound sign in the C locale (if implemented correctly) is printed as \243. Which characters are non-printable depends on the locale. (Because some versions of Windows get this wrong, all bytes with the upper bit set are regarded as printable on Windows in a single-byte locale.)

### Unicode and other multi-byte locales

In all locales, the characters in the ASCII range (0x00 to 0x7f) are printed in the same way, as-is if printable, otherwise via ANSI escape sequences or 3-digit octal escapes as described for single-byte locales.

Multi-byte non-printing characters are printed as an escape sequence of the form \uxxxx or \Uxxxxxxxx (in hexadecimal). This is the internal code for the wide-character representation of the character. If this is not known to be the Unicode point, a warning is issued. The only known exceptions are certain Japanese ISO2022 locales on commercial Unixes, which use a concatenation of the bytes: it is unlikely that R compiles on such a system.

It is possible to have a character string in a character vector that is not valid in the current locale. If a byte is encountered that is not part of a valid character it is printed in hex in the form \xab and this is repeated until the start of a valid character. (This will rapidly recover from minor errors in UTF-8.)

### See Also

The generic `print`, `options`. The `"noquote"` class and print method.

`encodeString`, which encodes a character vector the way it would be printed.

### Examples

    pi
    print(pi, digits = 16)
    LETTERS[1:16]
    print(LETTERS, quote = FALSE)

    M <- cbind(I = 1, matrix(1:10000, ncol = 10,
                             dimnames = list(NULL, LETTERS[1:10])))
    utils::head(M) # makes more sense than
    print(M, max = 1000)# prints 90 rows and a message about omitting 910

[Package base version 2.15.1 Index]