CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Commatizing numbers

From Rosetta Code
Commatizing numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Commatizing   numbers (as used here, a handy expedient made-up word) is the act of adding commas to a number (or string), or the numeric part of a larger string.


Task

Write a function that takes a string as an argument with optional arguments or parameters (the format of parameters/options is left to the programmer) that in general, adds commas (or some other characters, including blanks or tabs) to the first numeric part of a string (if it's suitable for commatizing as per the rules below), and returns that newly commatized string.

Some of the commatizing rules (specified below) are arbitrary, but they'll be a part of this task requirements, if only to make the results consistent amongst national preferences and other disciplines.

The number may be part of a larger (non-numeric) string such as:

  •   «US$1744 millions»       ──or──
  •   ±25000 motes.


The string may possibly not have a number suitable for commatizing, so it should be untouched and no error generated.

If any argument (option) is invalid, nothing is changed and no error need be generated (quiet execution, no fail execution).   Error message generation is optional.

The exponent part of a number is never commatized.   The following string isn't suitable for commatizing:   9.7e+12000

Leading zeroes are never commatized.   The string   0000000005714.882   after commatization is:   0000000005,714.882

Any   period   (.)   in a number is assumed to be a   decimal point.

The original string is never changed   except   by the addition of commas   [or whatever character(s) is/are used for insertion], if at all.

To wit, the following should be preserved:

  •   leading signs (+, -)       ── even superfluous signs
  •   leading/trailing/embedded blanks, tabs, and other whitespace
  •   the case (upper/lower) of the exponent indicator, e.g.:   4.8903d-002


Any exponent character(s) should be supported:

  •   1247e12
  •   57256.1D-4
  •   4444^60
  •   750010**35
  •   8500x10**35
  •   +55000↑3
  •   1000**100
  •   2048²
  •   409632
  •   10000pow(pi)


Numbers may be terminated with any non-digit character, including subscripts and/or superscript:   41421356243   or   7320509076(base 24).

The character(s) to be used for the comma can be specified, and may contain blanks, tabs, and other whitespace characters, as well as multiple characters.   The default is the comma (,) character.

The   period length   can be specified   (sometimes referred to as "thousands" or "thousands separators").   The   period length   can be defined as the length (or number) of the decimal digits between commas.   The default period length is   3.

E.G.:   in this example, the   period length   is five:   56789,12340,14148

The location of where to start the scanning for the target field (the numeric part) should be able to be specified.   The default is   1.

The character strings below may be placed in a file (and read) or stored as simple strings within the program.


Strings to be used as a minimum

The value of   pi   (expressed in base 10)   should be separated with blanks every   5   places past the decimal point,
the Zimbabwe dollar amount should use a decimal point for the "comma" separator:

  •   pi=3.14159265358979323846264338327950288419716939937510582097494459231
  •   The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
  •   "-in Aus$+1411.8millions"
  •   ===US$0017440 millions=== (in 2000 dollars)
  •   123.e8000 is pretty big.
  •   The land area of the earth is 57268900(29% of the surface) square miles.
  •   Ain't no numbers in this here words, nohow, no way, Jose.
  •   James was never known as 0000000007
  •   Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
  •   ␢␢␢$-140000±100 millions.
  •   6/9/1946 was a good year for some.


where the penultimate string has three leading blanks   (real blanks are to be used).


Also see

ALGOL 68[edit]

# returns text commatized according to the rules of the task and the      #
# period, location and separator paramters #
PROC commatize = ( STRING text, INT location, INT period, STRING separator )STRING:
IF STRING str := text[ AT 1 ];
# handle the options #
INT start position := IF location = 0 THEN 1 ELSE location FI;
INT period length := IF period = 0 THEN 3 ELSE period FI;
STRING separator string := IF separator = "" THEN "," ELSE separator FI;
period length < 1 OR start position < 1 OR start position > UPB str
THEN
# invalid parameters - return the text unchanged #
text
ELIF # attempt to find a non-zero digit #
INT number pos := start position;
WHILE IF number pos > UPB str
THEN FALSE
ELSE str[ number pos ] < "1" OR str[ number pos ] > "9"
FI
DO
number pos +:= 1
OD;
number pos > UPB str
THEN # no digits in the string - return the text unchanged #
text
ELSE # have at least one digit #
STRING result := str[ 1 : number pos - 1 ];
# find the final digit #
INT number end := number pos;
WHILE IF number end >= UPB str
THEN FALSE
ELSE str[ number end + 1 ] >= "0" AND str[ number end + 1 ] <= "9"
FI
DO
number end +:= 1
OD;
# copy the digits commatizing as required #
INT digit count := ( number end - number pos ) + 1;
WHILE digit count > 1 DO
result +:= str[ number pos ];
number pos +:= 1;
digit count -:= 1;
IF digit count MOD period length = 0 THEN
# need a comma after this digit #
result +:= separator string
FI
OD;
# final digit and the rest of the string #
result +:= str[ number pos : ];
result
FI # commatize # ;
 
# modes and operators to allow us to specify optional parameters to the #
# commatizing procedure #
MODE COMMATIZINGOPTIONS = STRUCT( STRING text, INT location, INT period, STRING separator );
PRIO LOCATION = 9;
OP LOCATION = ( STRING text, INT location )COMMATIZINGOPTIONS: COMMATIZINGOPTIONS( text, location, 0, "" );
PRIO PERIOD = 9;
OP PERIOD = ( STRING text, INT period )COMMATIZINGOPTIONS: COMMATIZINGOPTIONS( text, 0, period, "" );
PRIO SEPARATOR = 9;
OP SEPARATOR = ( STRING text, CHAR separator )COMMATIZINGOPTIONS: COMMATIZINGOPTIONS( text, 0, 0, separator );
OP SEPARATOR = ( STRING text, STRING separator )COMMATIZINGOPTIONS: COMMATIZINGOPTIONS( text, 0, 0, separator );
OP LOCATION = ( COMMATIZINGOPTIONS opts, INT location )COMMATIZINGOPTIONS:
COMMATIZINGOPTIONS( text OF opts, location, period OF opts, separator OF opts );
OP PERIOD = ( COMMATIZINGOPTIONS opts, INT period )COMMATIZINGOPTIONS:
COMMATIZINGOPTIONS( text OF opts, location OF opts, period, separator OF opts );
OP SEPARATOR = ( COMMATIZINGOPTIONS opts, CHAR separator )COMMATIZINGOPTIONS:
COMMATIZINGOPTIONS( text OF opts, location OF opts, period OF opts, separator );
OP SEPARATOR = ( COMMATIZINGOPTIONS opts, STRING separator )COMMATIZINGOPTIONS:
COMMATIZINGOPTIONS( text OF opts, location OF opts, period OF opts, separator );
OP COMMATIZE = ( STRING text )STRING: commatize( text, 0, 0, "" );
OP COMMATIZE = ( COMMATIZINGOPTIONS opts )STRING:
commatize( text OF opts, location OF opts, period OF opts, separator OF opts );
 
# test the commatization procedure and operators #
print( ( COMMATIZE( "pi=3.14159265358979323846264338327950288419716939937510582097494459231" PERIOD 5 SEPARATOR " " LOCATION 6 ),
newline ) );
print( ( COMMATIZE( "The author has two Z$100000000000000 Zimbabwe notes (100 trillion)." SEPARATOR "." ), newline ) );
print( ( COMMATIZE """-in Aus$+1411.8millions""", newline ) );
print( ( COMMATIZE "===US$0017440 millions=== (in 2000 dollars)", newline ) );
print( ( COMMATIZE "123.e8000 is pretty big.", newline ) );
print( ( COMMATIZE "The land area of the earth is 57268900(29% of the surface) square miles.", newline ) );
print( ( COMMATIZE "Ain't no numbers in this here words, nohow, no way, Jose.", newline ) );
print( ( COMMATIZE "James was never known as 0000000007", newline ) );
print( ( COMMATIZE "Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.",
newline ) );
print( ( COMMATIZE " $-140000±100 millions.", newline ) );
print( ( COMMATIZE "6/9/1946 was a good year for some.", newline ) )
Output:
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
   $-140,000±100 millions.
6/9/1946 was a good year for some.

D[edit]

import std.stdio, std.regex, std.string, std.range, std.conv;
 
auto commatize(in char[] txt, in uint start=0, in uint step=3, in string ins=",")
/*pure nothrow*/ @safe in {
assert(step > 0);
} body {
if (start > txt.length || step > txt.length)
return txt;
 
return txt[0 .. start] ~ txt[start .. $]
.replaceAll!(m => m.hit.retro.chunks(step).join(ins).retro)
("[1-9][0-9]*".regex);
}
 
void main() {
foreach (const line; "commatizing_numbers_data.txt".File.byLine)
line.commatize.write;
}
Output:
pi=3.14,159,265,358,979,323,846,264,338,327,950,288,419,716,939,937,510,582,097,494,459,231
The author has two Z$100,000,000,000,000 Zimbabwe notes (100 trillion).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2,000 dollars) 
123.e8,000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
   $-140,000±100 millions.
6/9/1,946 was a good year for some.

J[edit]

These rules are relatively baroque, which demands long names and minimally complex statements, thus:

require'regex'
commatize=:3 :0"1 L:1 0
(i.0) commatize y
:
NB. deal with all those rules about options
opts=. boxopen x
char=. (#~ ' '&=@{.@(0&#)@>) opts
num=. ;opts-.char
delim=. 0 {:: char,<','
'begin period'=. _1 0+2{.num,(#num)}.1 3
NB. initialize
prefix=. begin {.y
text=. begin }. y
NB. process
'start len'=. ,'[1-9][0-9]*' rxmatch text
if.0=len do. y return. end.
number=. (start,:len) [;.0 text
numb=. (>:period|<:#number){.number
fixed=. numb,;delim&,each (-period)<\ (#numb)}.number
prefix,(start{.text),fixed,(start+len)}.text
)

In use, this might look like:

   (5;5;' ') commatize 'pi=3.14159265358979323846264338327950288419716939937510582097494459231'
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
'.' commatize 'The author has two Z$100000000000000 Zimbabwe notes (100 trillion).'
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
commatize '-in Aus$+1411.8millions'
-in Aus$+1,411.8millions
commatize '===US$0017440 millions=== (in 2000 dollars)'
===US$0017,440 millions=== (in 2000 dollars)
commatize '123.e8000 is pretty big.'
123.e8000 is pretty big.
commatize 'The land area of the earth is 57268900(29% of the surface) square miles.'
The land area of the earth is 57,268,900(29% of the surface) square miles.
commatize 'Ain''t no numbers in this here words, nohow, no way, Jose.'
Ain't no numbers in this here words, nohow, no way, Jose.
commatize 'James was never known as 0000000007'
James was never known as 0000000007
commatize 'Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.'
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
commatize ' $-140000±100 millions.'
$-140,000±100 millions.
commatize '6/9/1946 was a good year for some.'
6/9/1946 was a good year for some.

Java[edit]

import java.io.File;
import java.util.*;
import java.util.regex.*;
 
public class CommatizingNumbers {
 
public static void main(String[] args) throws Exception {
commatize("pi=3.14159265358979323846264338327950288419716939937510582"
+ "097494459231", 6, 5, " ");
 
commatize("The author has two Z$100000000000000 Zimbabwe notes (100 "
+ "trillion).", 0, 3, ".");
 
try (Scanner sc = new Scanner(new File("input.txt"))) {
while(sc.hasNext())
commatize(sc.nextLine());
}
}
 
static void commatize(String s) {
commatize(s, 0, 3, ",");
}
 
static void commatize(String s, int start, int step, String ins) {
if (start < 0 || start > s.length() || step < 1 || step > s.length())
return;
 
Matcher m = Pattern.compile("([1-9][0-9]*)").matcher(s.substring(start));
StringBuffer result = new StringBuffer(s.substring(0, start));
 
if (m.find()) {
StringBuilder sb = new StringBuilder(m.group(1)).reverse();
for (int i = step; i < sb.length(); i += step)
sb.insert(i++, ins);
m.appendReplacement(result, sb.reverse().toString());
}
 
System.out.println(m.appendTail(result));
}
}
pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
"-in Aus$+1,411.8millions"
===US$0017,440 millions=== (in 2000 dollars)
123.e8000 is pretty big.
The land area of the earth is 57,268,900(29% of the surface) square miles.
Ain't no numbers in this here words, nohow, no way, Jose.
James was never known as 0000000007
Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
   $-140,000±100 millions.
6/9/1946 was a good year for some.

Perl 6[edit]

commatize 'pi=3.14159265358979323846264338327950288419716939937510582097494459231', :at(6), :ins(' '), :by(5);
commatize 'The author has two Z$100000000000000 Zimbabwe notes (100 trillion).', :ins<.>;
commatize '-in Aus$+1411.8millions';
commatize '===US$0017440 millions=== (in 2000 dollars)';
commatize '123.e8000 is pretty big.';
commatize 'The land area of the earth is 57268900(29% of the surface) square miles.';
commatize 'Ain\'t no numbers in this here words, nohow, no way, Jose.';
commatize 'James was never known as 0000000007';
commatize 'Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.';
commatize ' $-140000±100 millions.';
commatize '6/9/1946 was a good year for some.';
 
sub commatize($s, :$at = 0, :$ins = ',', :$by = 3) {
say "Before: ", $s;
say " After: ", $s.subst:
:continue($at), :1st,
/ <[1..9]> <[0..9]>* /,
*.flip.comb(/<{ ".**1..$by" }>/).join($ins).flip;
}
Output:
Before: pi=3.14159265358979323846264338327950288419716939937510582097494459231
 After: pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231
Before: The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
 After: The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).
Before: -in Aus$+1411.8millions
 After: -in Aus$+1,411.8millions
Before: ===US$0017440 millions=== (in 2000 dollars)
 After: ===US$0017,440 millions=== (in 2000 dollars)
Before: 123.e8000 is pretty big.
 After: 123.e8000 is pretty big.
Before: The land area of the earth is  57268900(29% of the surface)  square miles.
 After: The land area of the earth is  57,268,900(29% of the surface)  square miles.
Before: Ain't no numbers in this here words, nohow, no way, Jose.
 After: Ain't no numbers in this here words, nohow, no way, Jose.
Before: James was never known as  0000000007
 After: James was never known as  0000000007
Before: Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
 After: Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.
Before:    $-140000±100  millions.
 After:    $-140,000±100  millions.
Before: 6/9/1946 was a good year for some.
 After: 6/9/1946 was a good year for some.

Racket[edit]

Note that the post-number part of the split catches the date in 6/9/1946 (I think that's desirable) but 1946-09-06 would still be commatized as 1,946-09-06 -- it would take date recognition to capture that case.

All tests pass (so it's as good as Perl, I guess).

#lang racket
(require (only-in srfi/13 [string-reverse gnirts]))
 
;; returns a string with the "comma"s inserted every step characters from the RIGHT of n.
;; because of the right handedness of this, there is a lot of reversal going on
(define ((insert-commas comma step) n)
(define px (pregexp (format ".{1,~a}" step)))
(string-join (add-between (reverse (map gnirts (regexp-match* px (gnirts n)))) comma) ""))
 
(define (commatize s #:start (start 0) #:comma (comma ",") #:step (step 3))
(define ins-comms (insert-commas comma step)) ; specific to our comma and step
 
(define split-into-numbers
(match-lambda
[(regexp
#px"^([^1-9]*)([1-9][0-9.]*)(\\S*)(.*)$" ; see below for description of bits
(list _  ; the whole match
(app split-into-numbers pre)  ; recur on left
num  ; the number bit before any exponent or other
 ; interestingness
post-number  ; from exponent to the first space
(app split-into-numbers post))) ; recur on right
(define skip (substring num 0 start))
(match-define
(regexp #px"^(.*?)(\\..*)?$"
(list _  ; whole match
(app ins-comms n)  ; the bit that gets the commas added
(or (? string? d)  ; if it matches, then the raw string is in d
(and #f (app (lambda (f) "") d))))) ; if (...)? doesn't match it returns
 ; #f which we thunk to an empty string
(substring num start))  ; do the match on the unskipped bit
(string-append pre skip n d post-number post)] ; stitch it back together
[else else]))  ; if it doesn't match leave as is
 
 ;; kick it off
(split-into-numbers s))
 
(module+ test
(require tests/eli-tester)
 
(test
(commatize "pi=3.14159265358979323846264338327950288419716939937510582097494459231"
#:start 6 #:comma " " #:step 5)
=>"pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231"
 
(commatize "The author has two Z$100000000000000 Zimbabwe notes (100 trillion)." #:comma ".")
=>"The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion)."
 
(commatize "-in Aus$+1411.8millions")
=>"-in Aus$+1,411.8millions"
 
(commatize "===US$0017440 millions=== (in 2000 dollars)")
=>"===US$0017,440 millions=== (in 2,000 dollars)"
 
(commatize "123.e8000 is pretty big.")
=>"123.e8000 is pretty big."
 
(commatize "The land area of the earth is 57268900(29% of the surface) square miles.")
=>"The land area of the earth is 57,268,900(29% of the surface) square miles."
 
(commatize "Ain't no numbers in this here words, nohow, no way, Jose.")
=>"Ain't no numbers in this here words, nohow, no way, Jose."
 
(commatize "James was never known as 0000000007")
=>"James was never known as 0000000007"
 
(commatize "Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.")
=>"Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe."
 
(commatize " $-140000±100 millions.")
 
=>" $-140,000±100 millions."
(commatize "6/9/1946 was a good year for some.")
=>"6/9/1946 was a good year for some."))
 

REXX[edit]

The hardest part of the   comma   function is to locate where a useable number starts and ends.

/*REXX program add commas (or other chars)  to a number within a string.*/
@. =
@.1="pi=3.14159265358979323846264338327950288419716939937510582097494459231"
@.2="The author has two Z$100000000000000 Zimbabwe notes (100 trillion)."
@.3="-in Aus$+1411.8millions"
@.4="===US$0017440 millions=== (in 2000 dollars)"
@.5="123.e8000 is pretty big."
@.6="The land area of the earth is 57268900(29% of the surface) square miles."
@.7="Ain't no numbers in this here words, nohow, no way, Jose."
@.8="James was never known as 0000000007"
@.9="Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe."
@.10=" $-140000±100 millions."
@.11="6/9/1946 was a good year for some."
 
do i=1 while @.i\==''; if i\==1 then say /*process each string*/
say 'before:'@.i /*show the before str*/
if i==1 then say ' after:'comma(@.i,'blank',5,,6) /*p=5, start=6*/
if i==2 then say ' after:'comma(@.i,".") /*comma=decimal point*/
if i>2 then say ' after:'comma(@.i) /*use the defaults. */
end /*j*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────COMMA subroutine────────────────────*/
comma: procedure; parse arg _,c,p,t,s /*get number and optional options*/
arg ,cU . /*get an uppercase version of C.*/
c=word(c ',', 1) /*get the commatizing char(s).*/
if cU=='BLANK' then c=' ' /*special case for a "blank" sep.*/
o=word(p 3, 1) /*get the optional period length.*/
p=abs(o) /*get the positive period length.*/
t=word(t 999999999, 1) /*get max# of "commas" to insert.*/
s=word(s 1, 1) /*get optional start position. */
 
if \datatype(p,'W') | \datatype(t,"W") | \datatype(s,'W') |,
t<1 | s<1 | p==0 | arg()>5 then return _ /*invalid options?*/
 
n=_'.9'; #=123456789; k=0 /*define some handy-dandy vars. */
 
if o<0 then do /*using a negative period length.*/
b=verify(_,' ', , s) /*position of 1st blank in string*/
e=length(_) - verify(reverse(_), ' ') + 1 - p
end
else do /*using a positive period length.*/
b=verify(n, #, "M", s) /*position of 1st useable digits.*/
z=max(1, verify(n, #"0.", 'M', s))
e=verify(n, #'0', , max(1, verify(n, #"0.", 'M', s))) - p - 1
end
 
if e>0 & b>0 then do j=e to b by -p while k<t /*commatize the digs*/
_=insert(c, _, j) /*comma spray ──► #.*/
k=k+1 /*bump commatizing. */
end /*j*/
return _

output when using the internal strings for input:

before──►pi=3.14159265358979323846264338327950288419716939937510582097494459231
 after──►pi=3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510 58209 74944 59231

before──►The author has two Z$100000000000000 Zimbabwe notes (100 trillion).
 after──►The author has two Z$100.000.000.000.000 Zimbabwe notes (100 trillion).

before──►-in Aus$+1411.8millions
 after──►-in Aus$+1,411.8millions

before──►===US$0017440 millions=== (in 2000 dollars)
 after──►===US$0017,440 millions=== (in 2000 dollars)

before──►123.e8000 is pretty big.
 after──►123.e8000 is pretty big.

before──►The land area of the earth is  57268900(29% of the surface)  square miles.
 after──►The land area of the earth is  57,268,900(29% of the surface)  square miles.

before──►Ain't no numbers in this here words, nohow, no way, Jose.
 after──►Ain't no numbers in this here words, nohow, no way, Jose.

before──►James was never known as  0000000007
 after──►James was never known as  0000000007

before──►Arthur Eddington wrote: I believe there are 15747724136275002577605653961181555468044717914527116709366231425076185631031296 protons in the universe.
 after──►Arthur Eddington wrote: I believe there are 15,747,724,136,275,002,577,605,653,961,181,555,468,044,717,914,527,116,709,366,231,425,076,185,631,031,296 protons in the universe.

before──►   $-140000±100  millions.
 after──►   $-140,000±100  millions.

before──►6/9/1946 was a good year for some.
 after──►6/9/1946 was a good year for some.