**Formatting Using C-style Formats**

Formatting numbers individually and flexibly, using `C`

style format specifications.

formatC(x, digits = NULL, width = NULL, format = NULL, flag = "", mode = NULL, big.mark = "", big.interval = 3, small.mark = "", small.interval = 5, decimal.mark = ".", preserve.width = "individual") prettyNum(x, big.mark = "", big.interval = 3, small.mark = "", small.interval = 5, decimal.mark = ".", preserve.width = c("common", "individual", "none"), zero.print = NULL, ...)

`x` |
---|

of real numbers. |

`digits` |
---|

point (`format = “f”`

) or *significant* digits (`format = “g”`

, `= “e”`

or `= “fg”`

).

Default: 2 for integer, 4 for real numbers. If less than 0, the C default of 6 digits is used. |

`width` |
---|

`width`

are unspecified, `width`

defaults to 1, otherwise to `digits + 1`

. `width = 0`

will use `width = digits`

, `width < 0`

means left justify the number in this field (equivalent to `flag =”-”`

). If necessary, the result will have more characters than `width`

. |

`format` |
---|

`“e”`

, `“E”`

, `“g”`

, `“G”`

, `“fg”`

(for reals), or `“s”`

(for strings). Default is `“d”`

for integers, `“g”`

for reals.

`“f”`

gives numbers in the usual `xxx.xxx`

format; `“e”`

and `“E”`

give `n.ddde+nn`

or `n.dddE+nn`

(scientific format); `“g”`

and `“G”`

put `x[i]`

into scientific format only if it saves space to do so.

`“fg”`

uses fixed format as `“f”`

, but `digits`

as the minimum number of *significant* digits. That this can lead to quite long result strings, see examples below. Note that unlike `signif`

this prints large numbers with more significant digits than `digits`

. |

`flag` |
---|

format modifier as in Kernighan and Ritchie (1988, page 243). `“0”`

pads leading zeros; `“-”`

does left adjustment, others are `“+”`

, `” “`

, and `“#”`

. There can be more than one of these, in any order. |

`mode` |
---|

`“character”`

. Default: Determined from the storage mode of `x`

. |

`big.mark` |
---|

`big.interval`

decimals *before* (hence `big`

) the decimal point. |

`big.interval` | see `big.mark` above; defaults to 3. |
---|---|

`small.mark` |

`small.interval`

decimals *after* (hence `small`

) the decimal point. |

`small.interval` | see `small.mark` above; defaults to 5. |
---|---|

`decimal.mark` |

decimal point. |

`preserve.width` |
---|

be preserved where possible in those cases where marks (`big.mark`

or `small.mark`

) are added. `“common”`

, the default, corresponds to `format`

-like behavior whereas `“individual”`

is the default in `formatC()`

. |

`zero.print` |
---|

if and how *zeros* should be formatted specially. Useful for pretty printing “sparse” objects. |

`...` | arguments passed to `format` . |
---|

If you set `format`

it overrides the setting of `mode`

, so `formatC(123.45, mode=”double”, format=”d”)`

gives `123`

.

The rendering of scientific format is platform-dependent: some systems use `n.ddde+nnn`

or `n.dddenn`

rather than `n.ddde+nn`

.

`formatC`

does not necessarily align the numbers on the decimal point, so `formatC(c(6.11, 13.1), digits=2, format=”fg”)`

gives `c(“6.1”, " 13”)`

. If you want common formatting for several numbers, use `format`

.

`prettyNum`

is the utility function for prettifying `x`

. If `x`

is not a character, `format(x[i], ...)`

is applied to each element, and then it is left unchanged if all the other arguments are at their defaults. Note that `prettyNum(x)`

may behave unexpectedly if `x`

is a `character`

vector not resulting from something like `format(<number>)`

: in particular it assumes that a period is a decimal mark.

A character object of same size and attributes as `x`

. Unlike `format`

, each number is formatted individually. Looping over each element of `x`

, the C function `sprintf(...)`

is called (inside the C function `str_signif`

).

`formatC`

: for character `x`

, do simple (left or right) padding with white space.

`formatC`

was originally written by Bill Dunlap, later much improved by Martin Maechler. It was first adapted for by Friedrich Leisch.

Kernighan, B. W. and Ritchie, D. M. (1988) *The C Programming Language.* Second edition. Prentice Hall.

xx <- pi * 10^(-5:4) cbind(format(xx, digits=4), formatC(xx)) cbind(formatC(xx, wid = 9, flag = "-")) cbind(formatC(xx, dig = 5, wid = 8, format = "f", flag = "0")) cbind(format(xx, digits=4), formatC(xx, dig = 4, format = "fg")) formatC( c("a", "Abc", "no way"), wid = -7) # <=> flag = "-" formatC(c((-1:1)/0,c(1,100)*pi), wid=8, dig=1) xx <- c(1e-12,-3.98765e-10,1.45645e-69,1e-70,pi*1e37,3.44e4) ## 1 2 3 4 5 6 formatC(xx) formatC(xx, format="fg") # special "fixed" format. formatC(xx, format="f", dig=80)#>> also long strings r <- c("76491283764.97430", "29.12345678901", "-7.1234", "-100.1","1123") ## American: prettyNum(r, big.mark = ",") ## Some Europeans: prettyNum(r, big.mark = "'", decimal.mark = ",") (dd <- sapply(1:10, function(i)paste((9:0)[1:i],collapse=""))) prettyNum(dd, big.mark="'") ## examples of 'small.mark' pN <- stats::pnorm(1:7, lower=FALSE) cbind(format (pN, small.mark = " ", digits = 15)) cbind(formatC(pN, small.mark = " ", digits = 17, format = "f")) cbind(ff <- format(1.2345 + 10^(0:5), width = 11, big.mark = "'")) ## all with same width (one more than the specified minimum) ## individual formatting to common width: fc <- formatC(1.234 + 10^(0:8), format="fg", width=11, big.mark = "'") cbind(fc)