printoptions "suppression" of scientific method is not doing anything for large numbers?

[G778]

The documentation reads:

If True, always print floating point numbers using fixed point notation, in which case numbers equal to zero in the current precision will print as zero. If False, then scientific notation is used when absolute value of the smallest number is < 1e-4 or the ratio of the maximum absolute value to the minimum is > 1e3. The default is False.

But in actual use, when setting suppression for arrays with large enough numbers in them, it just stops working for some reason. This should work on all arrays with any size numbers, period, as promised.

I don't see any downsides to this, other than icky formatting if numbers scroll over to the next line, but this is "protecting people from themselves" and not helpful, especially when there's no such thing as a "no, like, really though, actually suppress..." flag I can set at the same time, or similar.

[pv]

arrays with large enough numbers in them, it just stops working for some reason

Please give an example (ie. Python code that prints stuff the wrong way), so that it's not necessary to spend time guessing what this means exactly.

[G778]

Example. It seems to work as expected when the numbers are just 15, 17, 103, etc., but "big" numbers it goes back to ignoring my request.

[ewmoore]

Suppress is about suppress small values. I pretty sure it does nothing for large values. Do you really want a print out of potentially hundreds of digits for each number? Anyway I'm sure that you can make this work by supplying a customer formatter.

…

On Tue, Jul 10, 2018 at 5:32 PM, G778 ***@***.***> wrote: [image: image] <https://user-images.githubusercontent.com/41085010/42538864-05fb71da-844e-11e8-9fc0-eb49b7c80bce.png> Example. It seems to work as expected when the numbers are just 15, 17, 103, etc., but "big" numbers it goes back to ignoring my request. — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#11547 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ACNRkb93NZOGI8j49weXZ8pygFpJyOPPks5uFR2EgaJpZM4VKBY0> .

[G778]

Hundreds of digits?? No, in most people's applications, numbers come from real places in the world which tend not to feature numbers that high. For example, accounting.

Some people have billions of dollars or stocks or pounds of grain, and yes, I want to be able to see the difference at a glance from 10 million by using normal formatting.

Also, as importantly, regardless of what I want, the documentation promises this but doesn't deliver it for "suppress"

The custom formatter does not seem to work for this. It will change how much precision is displayed and so on, but cannot seem to override scientific notation no matter what I try.

Please indicate a custom formatted code example that you have found able to do this if so?

[eric-wieser]

For example, accounting.

As an aside - what we're discussion here is the formatting of floating point numbers - and you should not be using floating point numbers for accounting

[rkern]

[~]
|15> a = np.array([0.0, 1.0, 1.2345678901234567890e200])

[~]
|16> print(a)
[  0.00000000e+000   1.00000000e+000   1.23456789e+200]

[~]
|17> np.set_printoptions(formatter=dict(float='{:f}'.format))

[~]
|18> print(a)
[0.000000 1.000000
 123456789012345674980922609384950994995781171363245042470764995455286780723397406860586154634216772122337447431885435765589258553158739889120251130820193718653328991910632731679075130059875908342251520.000000]

[leolchat]

Don't we agree that the documentation should explain that? If so, I could do a PR for the documentation at least.

[rossbar]

There does seem to be a bit of undocumented behavior: suppress does prevent scientific notation for large numbers but only up to a hard-coded cutoff of 1e8. This can be seen in line 873 of the following snippet:

numpy/numpy/core/arrayprint.py

Lines 834 to 876 in 872c6b7

	class FloatingFormat:
	""" Formatter for subtypes of np.floating """
	def __init__(self, data, precision, floatmode, suppress_small, sign=False,
	*, legacy=None):
	# for backcompatibility, accept bools
	if isinstance(sign, bool):
	sign = '+' if sign else '-'
	self._legacy = legacy
	if self._legacy == '1.13':
	# when not 0d, legacy does not support '-'
	if data.shape != () and sign == '-':
	sign = ' '
	self.floatmode = floatmode
	if floatmode == 'unique':
	self.precision = None
	else:
	self.precision = precision
	self.precision = _none_or_positive_arg(self.precision, 'precision')
	self.suppress_small = suppress_small
	self.sign = sign
	self.exp_format = False
	self.large_exponent = False
	self.fillFormat(data)
	def fillFormat(self, data):
	# only the finite values are used to compute the number of digits
	finite_vals = data[isfinite(data)]
	# choose exponential mode based on the non-zero finite values:
	abs_non_zero = absolute(finite_vals[finite_vals != 0])
	if len(abs_non_zero) != 0:
	max_val = np.max(abs_non_zero)
	min_val = np.min(abs_non_zero)
	with errstate(over='ignore'): # division can overflow
	if max_val >= 1.e8 or (not self.suppress_small and
	(min_val < 0.0001 or max_val/min_val > 1000.)):
	self.exp_format = True

This limit should be documented. An example like @rkern's on how to "suppress" scientific notation for arrays containing numbers larger than 1e8 would also be an improvement IMO.

[crkurdelak]

As of NumPy 2.1, the documentation for the suppress parameter in numpy.set_printoptions still does not mention the hardcoded limit of 1e8 that @rossbar discovered, and I have verified that this hardcoded value has not been changed since then:

numpy/numpy/_core/arrayprint.py

Lines 982 to 994 in c3a78be

	def fillFormat(self, data):
	# only the finite values are used to compute the number of digits
	finite_vals = data[isfinite(data)]
	# choose exponential mode based on the non-zero finite values:
	abs_non_zero = absolute(finite_vals[finite_vals != 0])
	if len(abs_non_zero) != 0:
	max_val = np.max(abs_non_zero)
	min_val = np.min(abs_non_zero)
	with errstate(over='ignore'): # division can overflow
	if max_val >= 1.e8 or (not self.suppress_small and
	(min_val < 0.0001 or max_val/min_val > 1000.)):
	self.exp_format = True

I think rossbar's suggestion of updating the documentation is a great idea.