Using the right numeric data type

Question

After becoming more engaged with training new engineers as well as reading Jon Skeet's DevDays presentation I have begun to recognize many engineers aren't clear when to use which numeric datatypes when. I appreciate the role a formal computer science degree plays in helping with this, but I see a lot of new engineers showing uncertainty because they have never worked with large data sets, or financial software, or programming phyiscs or statistics problems, or complex datastore issues.

My experience is that people really grok concepts when they are explained within context. I am looking for good examples of real programming problems where certain data is best represented using data type. Try to stay away from the textbook examples if possible. I am tagging this with Java, but feel free to give examples in other languages and retag:

Integer, Long, Double, Float, BigInteger, etc...

Answer 1

BigDecimal is the best when it comes to maintaining accurate floating point calculations, and being able to specify the desired accuracy. I believe float (and to some extent double) offer performance benefits over BigDecimal, but at the cost of accuracy and usability.

Answer 2

I really don't think you need examples or anything complex. This is simple:

• Is it a whole number?
  • Can it be > 2^63? BigInteger
  • Can it be > 2^31? long
  • Otherwise int
• Is it a decimal number?
  • Is an approximate value ok?
    • double
  • Does it need to be exact? (example: monetary amounts!)
    • BigDecimal

(When I say ">", I mean "greater in absolute value", of course.)

I've never used a byte or char to represent a number, and I've never used a short, period. That's in 12 years of Java programming. Float? Meh. If you have a huge array and you are having memory problems, I guess.

Note that BigDecimal is somewhat misnamed; your values do not have to be large at all to need it.

Answer 3

normally numeric if we're talking machine independenat (32/64bit) data type size are as below,

integer: 4 bytes

long: 8 bytes

decimal/float: 4bytes

double : 8bytes

and the sizes reduced to half for signed values (eg: for 4bytes, unsigned=4billions, signed=2billions)

bigInt (depends on language implementation) sometimes up to 10bytes.

for high volumes data archiving (such as search engine) i would highly recommended byte and short to save spaces.

byte: 1 byte, (0-256 unsigned, -128 - 128 signed)

short: 2 byte (65k unsigned)

---

let's say you want to save record about AGE, since nobody ever lives over 150, so you used data type BYTE (read above for size) but if you use INTEGER you already wasted extra 3bytes and seriously tell me wth live over 4billions yrs.

Answer 4

One important point you might want to articulate is that it's almost always an error to compare floating-point numbers for equality. For example, the following code is very likely to fail:

double euros = convertToEuros(item.getCostInDollars());
if (euros == 10.0) {
  // this line will most likely never be reached
}

This is one of many reasons why you want to use discrete numbers to represent currency.

When you absolutely must compare floating-point numbers, you can only do so approximately; something to the extent of:

double euros = convertToEuros(item.getCostInDollars());
if (Math.abs(euros - 10.0) < EPSILON) {
  // this might work
}

As for practical examples, my usual rule of thumb is something like this:

• double: think long and hard before using it; is the pain worth it ?
• float: don't use it
• byte: most often used as byte[] to represent some raw binary data
• int: this is your best friend; use it to represent most stuff
• long: use this for timestamps and database IDs
• BigDecimal and BigInteger: if you know about these, chances are you know what you're doing already, so you don't need my advice

I realize that these aren't terribly scientific rules of thumb, but if your target audience are not computer scientists, it might be best to stick to basics.