Support Unicode-2212 Minuses

[BenjaminWolfe]

Huge fan of the scales package.

In the last year or two I learned the hyphen minus (ASCII 45) and true minus (Unicode 2212) are different characters. The true minus is basically the plus without the vertical bar: It has the same length, thickness, and positioning as the plus's crossbar. So it looks really nice / professional with numbers and plots. It's also friendly to screen readers. But when I use the scales package as is I get hyphen-minuses.

I made the signs package to address this for anyone who's as much of an unabashed typography nerd as I am. But I only went with of a separate package because a) I was totally new to open-source contribution, and it was somewhat scary to touch someone else's work, especially work of which I'm such a fan; b) in the meantime I needed to use the functionality in my own work; and quite honestly c) I really thought only a few people would find the case compelling!

But the better way to do this, and one that will make me feel like a real citizen of the open-source community, would be to (also) submit a pull request to add the functionality to the scales package. And at rstudio::conf I met people who expressed interest in the difference between the characters. So I would truly love to work on this PR. (I'll add that I don't have to be the one working on it, if someone else on the team would prefer to take it up.)

Before I jump in, I'm guessing the right path is to open this issue and allow some discussion on how to proceed? I imagine I can save some headaches this way. My questions are...

• Any user-oriented design considerations, i.e. how you want the user to interact with it? I imagine making it as transparent as possible, maybe implementing it as an option users can set at the top of a script.
• What work would be involved? I.e. for someone who knows scales better than I, what's the quick outline of chunks of work I should do?
• And then: How can I truly best contribute to the work? Is it as simple as forking, trying it out, making sure all tests pass, and make a PR? Anything I should know?
• And, well... Anyone I might talk to mentor me through the process a bit? Any time I have this many questions on something, it's a clue that it might be helpful to just have a person to chat with. (Maybe @clauswilke... seemed interested in the use case, and I just learned we both live in Austin!!)

(Someday if I'm a more practiced open-source contributor than I am today, I expect this issue will remind me just how many unknowns there are for a neophyte!)

[clauswilke]

I think the right approach is to add this feature to the number() function:

scales/R/label-number.r

Lines 145 to 171 in be540d3

	number <- function(x, accuracy = NULL, scale = 1, prefix = "",
	suffix = "", big.mark = " ", decimal.mark = ".",
	trim = TRUE, ...) {
	if (length(x) == 0) return(character())
	accuracy <- accuracy %||% precision(x * scale)
	x <- round_any(x, accuracy / scale)
	nsmall <- -floor(log10(accuracy))
	nsmall <- min(max(nsmall, 0), 20)
	ret <- format(
	scale * x,
	big.mark = big.mark,
	decimal.mark = decimal.mark,
	trim = trim,
	nsmall = nsmall,
	scientific = FALSE,
	...
	)
	ret <- paste0(prefix, ret, suffix)
	ret[is.infinite(x)] <- as.character(x[is.infinite(x)])
	# restore NAs from input vector
	ret[is.na(x)] <- NA
	names(ret) <- names(x)
	ret
	}

There should probably be an option that allows me to turn this on or off, and/or to specify the character to use as a minus sign.

Since this is a simple helper function, you could just propose an implementation here in the issue, so we can have a discussion before you get into the weeds with a pull request.

Once number() has this feature we can talk about propagating it explicitly into all the other functions that use number(). (It will be propagated implicitly due to the ... arguments.)

[zeehio]

label_scientific would also benefit from a change like this.

A colleague was using a jupyter notebook with an R kernel and the data frame column width sometimes was breaking between the e and the exponent:

Something like: 4.5e-03 -> 4.5e\n-03

While the difference between hyphen minus and the minus sign (\u2122) is small and maybe only "typography nerds" would care :-) being or not a "breaking line character" has a more visible impact, in my opinion.

[BenjaminWolfe]

That's an excellent point, @zeehio. Thank you. I need to really dust this off and try my hand at it! In the meantime if your colleague is in a pinch they can try my signs package.

It's really just a wrapper for scales to swap out the hyphens and adds minuses, and it works for scientific formats as well. It parallels the older functions of scientific and scientific_format from before v1.1.0, but I have an open issue to bring that up to speed as well.

[teunbrand]

Hello there,

Since this is a simple helper function, you could just propose an implementation here in the issue, so we can have a discussion before you get into the weeds with a pull request.

Because the topic has been quiet over the past year, I thought to rekindle some discussion with an implementation proposal. Essentially, we add a signs argument that takes a character(3) vector, each element of which has a sign for negative, positive and zero numbers. We let signs[1] default to the true minus, and keep signs for positive and zero numbers empty characters.

library(scales)
library(rlang)

# Copy some internals for reproducibility
precision <- scales:::precision
round_any <- scales:::round_any

# Signs is a length 3 vector with symbols for negative, positive and zero
# signed numbers, in that order.
number <- function(x, accuracy = NULL, scale = 1, prefix = "",
                   suffix = "", big.mark = " ", decimal.mark = ".",
                   trim = TRUE, signs = c("\u2212","",""), ...) {
  if (length(x) == 0) return(character())
  accuracy <- accuracy %||% precision(x * scale)
  x <- round_any(x, accuracy / scale)
  nsmall <- -floor(log10(accuracy))
  nsmall <- min(max(nsmall, 0), 20)
  
  # Determine sign when x is still numeric to index with later
  x_sign <- sign(scale * x)
  x_sign[is.na(x_sign)] <- 0 # Protect against NA-indexing
  if (length(signs) < 3) {
    signs <- c(signs, rep("", 3 - length(signs)))
  }
  
  ret <- format(
    scale * x,
    big.mark = big.mark,
    decimal.mark = decimal.mark,
    trim = trim,
    nsmall = nsmall,
    scientific = FALSE,
    ...
  )
  # Substitute existing hyphens
  ret <- gsub("-", signs[1], ret)
  # Prefix zero and plus signs
  ret[x_sign == 1] <- paste0(signs[2], ret[x_sign == 1])
  ret[x_sign == 0] <- paste0(signs[3], ret[x_sign == 0])
  
  ret <- paste0(prefix, ret, suffix)
  ret[is.infinite(x)] <- as.character(x[is.infinite(x)])
  
  # restore NAs from input vector
  ret[is.na(x)] <- NA
  names(ret) <- names(x)
  
  ret
}

By default, it replaces hyphens with true minuses.

demo_continuous(-5:5, labels = ~ number(.x))
#> scale_x_continuous(labels = ~number(.x))

To show that other symbols work:

demo_continuous(-5:5, labels = ~ number(.x, signs = c("€", "$", "£")))
#> scale_x_continuous(labels = ~number(.x, signs = c("\200", "$", 
#>     "£")))

Some edge cases one might worry about. For reasons beyond my understanding, the reprex didn't print true minus symbols here, but it does print true minuses in my console. Currently infinites don't get their symbols, but that could be remedied.

number(c(-Inf, Inf, NA, NaN, -5, 5), signs = c("\u2212", "+"))
#> [1] "-Inf" "Inf"  NA     NA     "-5"   "+5"

^{Created on 2021-07-23 by the reprex package (v1.0.0)}

[clauswilke]

I like the idea in principle, but I would propose opening and closing signs. In business, negative numbers are often indicated by parentheses rather than the minus sign. That wouldn't be possible with your proposed API.

[teunbrand]

I must admit: I've never seen parentheses used like that, even in my time as data entry clerk, but a quick google proves you right. We could update to the following then, where we use a sign_prefix and a sign_suffix :

library(scales)
library(rlang)

# Copy some internals
precision <- scales:::precision
round_any <- scales:::round_any

# sign_prefix/sign_suffix is a `character(3)` vector with symbols for negative, positive and zero
# signed numbers.
number <- function(x, accuracy = NULL, scale = 1, prefix = "",
                   suffix = "", big.mark = " ", decimal.mark = ".",
                   trim = TRUE, 
                   sign_prefix = c("\u2212","",""),
                   sign_suffix = c("", "", ""),
                   ...) {
  if (length(x) == 0) return(character())
  accuracy <- accuracy %||% precision(x * scale)
  x <- round_any(x, accuracy / scale)
  nsmall <- -floor(log10(accuracy))
  nsmall <- min(max(nsmall, 0), 20)
  
  # Determine sign when x is still numeric
  x_sign <- sign(scale * x)
  x_sign[is.na(x_sign)] <- 0
  x_sign <- match(x_sign, c(-1, 1, 0))
  
  # Pad sign prefixes/suffixes with empty characters
  if (length(sign_prefix) < 3) {
    sign_prefix <- c(sign_prefix, rep("", 3 - length(sign_prefix)))
  }
  if (length(sign_suffix) < 3) {
    sign_suffix <- c(sign_suffix, rep("", 3 - length(sign_suffix)))
  }
  
  ret <- format(
    scale * x,
    big.mark = big.mark,
    decimal.mark = decimal.mark,
    trim = trim,
    nsmall = nsmall,
    scientific = FALSE,
    ...
  )
  # Substitute existing hyphens
  ret <- gsub("-", sign_prefix[1], ret)
  sign_prefix[1] <- ""
  # Apply sign prefixes and suffixes
  ret <- paste0(sign_prefix[x_sign], ret, sign_suffix[x_sign])

  ret <- paste0(prefix, ret, suffix)
  ret[is.infinite(x)] <- as.character(x[is.infinite(x)])
  
  # restore NAs from input vector
  ret[is.na(x)] <- NA
  names(ret) <- names(x)
  
  ret
}

demo_continuous(-5:5, labels = ~ number(.x, sign_prefix = "(", sign_suffix = ")"))
#> scale_x_continuous(labels = ~number(.x, sign_prefix = "(", sign_suffix = ")"))

^{Created on 2021-07-23 by the reprex package (v1.0.0)}

[hadley]

Should consider with #262

[hadley]

I'm open to this idea but we need to find the right interface. I think adding six extra parameters to the function feels a bit much in relation to the yield. It feels to me like we might be better off supplying functions? A more general specification should probably also reduce some of the complexity of dollar().

[hadley]

OTOH there is such a small number of total options it seems hard to justify extending the API so generally:

neg_parens <- function(x) paste0("(", x, ")")
neg_hyphen <- function(x) paste0("-", x)
neg_minus <- function(x) paste0("\u2212", x)
pos_plus <- function(x) paste0("+", x)
pos_null <- function(x) x

So maybe something like style_negative = c("hyphen", "parens", "minus"), style_positive = c("blank", "plus")?

[hadley]

One question that comes up is whether the prefix should actually go — for negative numbers should it go before or after the minus sign? Currently scales does $-100, which looking on the internet suggests is wrong, and it should actually be -$100.

But should it be USD -1 or -USD 1?