💡 LearnFrenzy Insight

Imagine measuring the height of a mountain. You might record the height as:

• 8848.86 metres
• 123.456 kilometres
• 0.0000035 metres

Scientific and engineering measurements often require very large or very small decimal values. The Double data type is designed to efficiently represent these floating-point numbers.

💡 Pro Tip: Double in Apex is a 64-bit (8-byte) floating-point number that follows the IEEE 754 standard. It can represent values from approximately 4.9e-324 to 1.8e+308.

⚠️ Important Note on Precision: Double can represent extremely large and small numbers, but with only about 15-16 digits of precision. This means very large numbers may lose precision in the decimal places.

📝 Key Points:

• Uninitialized Double variables default to null, not 0.0.
• Always initialize variables before using them in calculations.
• Scientific notation (like 1.5e-10) is useful for very small or large values.
• Use descriptive names like earthGravity or averageSpeed.

⚠️ Important: For scientific calculations, this behaviour is generally acceptable. For financial calculations involving currency, use Decimal instead of Double to avoid these precision issues.

🏢 Business Scenario 1: Manufacturing Analytics

A manufacturing application stores product weights and calculates average weight for analytical reporting.

Double totalWeight = 528.75;
Integer totalProducts = 15;
Double averageWeight = totalWeight / totalProducts;

System.debug('Total Weight: ' + totalWeight + ' kg');
System.debug('Number of Products: ' + totalProducts);
System.debug('Average Weight: ' + averageWeight + ' kg');  // 35.25

// Round for reporting
Double roundedAvg = Math.round(averageWeight * 100) / 100.0;
System.debug('Rounded Average: ' + roundedAvg + ' kg');  // 35.25

Output

Total Weight: 528.75 kg
Number of Products: 15
Average Weight: 35.25 kg
Rounded Average: 35.25 kg

In analytical applications where slight floating-point differences are acceptable, Double is an appropriate choice.

🏢 Business Scenario 2: Sales Performance Analytics

Calculate average sales performance for quarterly reporting.

// Monthly sales data
Double januarySales = 125000.50;
Double februarySales = 135000.75;
Double marchSales = 145000.25;

// Calculate quarterly total and average
Double quarterlyTotal = januarySales + februarySales + marchSales;
Double quarterlyAverage = quarterlyTotal / 3;

System.debug('Q1 Total: $' + quarterlyTotal);      // $405001.50
System.debug('Q1 Average: $' + quarterlyAverage);  // $135000.50

// Year-over-year growth calculation
Double lastYearQ1 = 380000.00;
Double growthPercent = ((quarterlyTotal - lastYearQ1) / lastYearQ1) * 100;
System.debug('Growth: ' + growthPercent + '%');  // 6.579342105263158%

Output

Q1 Total: $405001.50
Q1 Average: $135000.50
Growth: 6.579342105263158%

🏢 Business Scenario 3: Geography & Distance Calculation

Calculate distance between two locations using GPS coordinates (a common use case for Double).

// GPS Coordinates (Latitude, Longitude)
Double lat1 = 28.6139;   // New Delhi
Double lon1 = 77.2090;
Double lat2 = 19.0760;   // Mumbai
Double lon2 = 72.8777;

// Approximate distance calculation using Haversine formula
Double earthRadius = 6371.0;  // Earth radius in kilometers

Double latDiff = Math.toRadians(lat2 - lat1);
Double lonDiff = Math.toRadians(lon2 - lon1);

Double a = Math.sin(latDiff / 2) * Math.sin(latDiff / 2) +
           Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
           Math.sin(lonDiff / 2) * Math.sin(lonDiff / 2);

Double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
Double distance = earthRadius * c;

System.debug('Distance between Delhi and Mumbai: ' + distance + ' km');
// Approximate output: ~1150 km

💡 Pro Tip: The Math class in Apex provides over 30 mathematical functions that work with Double values, making it powerful for scientific and engineering computations.

Developer Writes
Double pi = 3.14159;

        │
        ▼

Compiler Checks
✔ Double Type exists?
✔ Variable name valid?
✔ Floating-Point value compatible?

        │
        ▼

Memory Allocated
64-bit (8 Bytes)

        │
        ▼

Binary Representation (IEEE 754)
0 10000000000 10010010000111111011011...

        │
        ▼

Available for Mathematical Operations
Used in formulas and scientific calculations

Double stores values in binary format using IEEE 754 standard, which can cause small rounding differences.

Scientific Formula Input
        │
        ▼
Floating-Point Calculation
Using binary arithmetic
        │
        ▼
Approximate Precision Result
May have small rounding errors
        │
        ▼
Result Returned
Used in analytics or reporting

✅ Best Practices

• Use Double for scientific and engineering calculations where approximate precision is acceptable.
• Use Decimal instead of Double for currency, tax, discounts, and financial values.
• Choose descriptive variable names such as averageSpeed, earthRadius, or gravityConstant.
• Understand that floating-point arithmetic may introduce tiny rounding differences.
• Use Math.abs(a - b) < tolerance when comparing Double values for equality.
• Always check for division by zero before performing division operations.
• Use scientific notation (1.5e-10) for very small or very large values.
• Initialize Double variables to avoid null pointer exceptions.

⚠️ Common Mistakes

• Using Double for Opportunity Amount or Invoice calculations (use Decimal instead).
• Expecting floating-point calculations to always produce exact decimal values.
• Confusing Double with Decimal because both support decimal numbers.
• Directly comparing Double values using == without tolerance.
• Forgetting that uninitialized Doubles are null, not 0.0.
• Using Double when Decimal precision is needed for business accuracy.
• Not handling Infinity or NaN values in calculations.

🎯 Interview Tip

Question: What is the primary difference between Double and Decimal in Apex?

Answer: Double uses floating-point arithmetic with approximately 15-16 digits of precision and is suitable for scientific or analytical calculations where approximate precision is acceptable. Decimal provides high-precision (up to 38 digits) exact decimal arithmetic and is the recommended choice for financial calculations such as Opportunity Amounts, Discounts, Taxes, Quotes, and Invoices.

Question: Why does 0.1 + 0.2 not equal 0.3 in Double?

Answer: This is due to the binary floating-point representation. In binary, 0.1 and 0.2 cannot be represented exactly, causing a small precision error. For example, 0.1 + 0.2 results in 0.30000000000000004 instead of 0.3. This is why Decimal is recommended for financial calculations where exact precision is required.

Question: When would you choose Double over Decimal?

Answer: Choose Double when working with very large or very small numbers (e.g., scientific constants like 6.022e23), performing complex mathematical operations (trigonometry, logarithms), when performance is critical, or when the calculation's precision requirements are not strict (e.g., analytical reports, statistical analysis).

📌 Quick Revision

• ✔ Stores floating-point decimal values (64-bit).
• ✔ Suitable for scientific, engineering, and analytical calculations.
• ✔ Supports a very large numeric range (~4.9e-324 to 1.8e+308).
• ✔ May introduce small floating-point rounding differences.
• ✔ Not recommended for financial calculations (use Decimal instead).
• ✔ Uses IEEE 754 double-precision format.
• ✔ Supports scientific notation (e.g., 1.5e-10).
• ✔ Common methods: Double.valueOf(), Math class functions.
• ✔ Use tolerance when comparing Double values for equality.
• ✔ Uninitialized Double variables default to null.

➡ Next Lesson

In the next lesson, you'll explore the Long data type in detail. You'll learn:

• How Apex stores very large whole numbers.
• The numeric range of Long and when to use it.
• When to use Long instead of Integer for large values.
• Common use cases and best practices for Long.
• Understanding the differences between Integer, Long, and Decimal.