liveBook · Manning

Float64

Also called Double, 64-bit floats

Float64 is a 64-bit floating-point numeric type, commonly represented by the IEEE 754 binary64 format.

How 8 Manning books explain it

JavaScript in Depth

The IEEE 754 double-precision binary floating-point format that represents real numbers using 64 bits.

How it is used
Explains JavaScript Number arithmetic, especially surprising decimal results and integer precision limits.
How deep it goes
Works through sign, biased exponent, significand, binary fraction addition, and rounding; distinguishes specified behavior from V8 storage optimizations.
Examples
Traces 0.1 + 0.2 through binary encoding and addition, then tests approximate equality and integers near 2^53.
What you can do after
Diagnose/debug rounding surprises and unsafe integers; choose scale-aware comparisons while recognizing runtime-specific integer optimizations.

Read how JavaScript in Depth explains float64 →

Modern C, Third Edition

double is a C floating-point type providing at least the precision and range required for double-precision real-number calculations.

How it is used
Uses double for real floating-point values and for decimal literals requiring floating-point semantics.
How deep it goes
Defines precision and approximation, then compares literal spellings, but stops short of detailing floating-point storage internals.
Examples
Uses 0.2, extended decimal spellings, and hexadecimal floating-point literals to demonstrate approximation and representation.
What you can do after
Evaluate/understand why double literals can have rounded effective values and how hexadecimal notation changes their spelling.

Read how Modern C, Third Edition explains float64 →

DuckDB in Action

A double is a floating-point numeric data type that stores values with approximately twice the precision of a single-precision value.

How it is used
Corrects inferred string fields so nested JSON data supports numeric analysis in DuckDB.
How deep it goes
Explains schema inspection, whole-STRUCT casting, and verification, but defers floating-point representation internals.
Examples
Uses football shot coordinates, expected-goals values, corrected schemas, and team-level xG totals.
What you can do after
Operate/configure DuckDB to cast inferred JSON fields and perform numeric queries over flattened records.

Read how DuckDB in Action explains float64 →

100 Java Mistakes and How to Avoid Them

How it is used
Uses float64 for numeric algorithms while exposing representation, boundary-constant, and precision-conversion traps.
How deep it goes
Explains signed zero, extrema constants, and widening precision loss with code consequences, but does not develop full floating-point arithmetic.
Examples
Uses signed-zero multiplication, boxed equality, a flawed maximum search, and long values that collide after double conversion.
What you can do after
Diagnose float64 bugs involving signed zero, incorrect extrema initialization, and silently rounded widening conversions.

Read how 100 Java Mistakes and How to Avoid Them explains float64 →

Pandas Workout: 200 exercises to make you a stronger data analyst

float64 is a 64-bit floating-point data type commonly used as the default numeric precision for pandas columns.

How it is used
Handles decimal values and missing data in pandas columns during data-frame manipulation and analysis.
How deep it goes
Explains dtype coercion, floating-point surprises, and precision tradeoffs, but stops short of floating-point internals.
Examples
Uses a product-sales data frame and NYC taxi totals to demonstrate missing values, arithmetic differences, and alternative precision.
What you can do after
Diagnose unexpected float64 conversion and evaluate whether higher precision justifies additional memory and reduced portability.

Read how Pandas Workout: 200 exercises to make you a stronger data analyst explains float64 →

ScyllaDB in Action

DOUBLE is a ScyllaDB floating-point data type for storing double-precision numeric values.

How it is used
Stores decimal-valued fields when 64-bit floating-point representation fits the application’s precision requirements.
How deep it goes
Defines size, encoding, usage, and precision trade-offs, but does not detail floating-point internals or numeric limits.
Examples
Demonstrates DOUBLE with the CQL value 567.8 and retrieves it alongside FLOAT value 123.4.
What you can do after
Apply it via CQL by inserting and selecting double-precision values, while recognizing when DECIMAL is safer.

Read how ScyllaDB in Action explains float64 →

100 Go Mistakes and How to Avoid Them

float64 is Go's 64-bit floating-point type with an 11-bit exponent, a 52-bit mantissa, and a sign bit.

How it is used
Explains fractional values, approximation effects, arithmetic surprises, and numeric types produced by JSON unmarshaling.
How deep it goes
Defines the IEEE-754 bit layout and demonstrates rounding, accumulation order, expression order, special values, and JSON conversion.
Examples
Uses multiplication, repeated addition, reassociated expressions, special-value divisions, and decoded JSON identifiers.
What you can do after
Diagnose unexpected rounding, accumulation differences, special values, and numeric type assertions in decoded maps.

Read how 100 Go Mistakes and How to Avoid Them explains float64 →

Deep Learning with JAX

A 64-bit floating-point numeric type used as a higher-precision array data type in numerical computing.

How it is used
Uses float64 for high-precision scientific calculations when float32's precision is insufficient.
How deep it goes
Explains IEEE 754 layout, precision, range, JAX defaults, startup configuration, and backend caveats.
Examples
Demonstrates enabling x64 mode, constructing a float64 JAX array, and checking its dtype.
What you can do after
Operate/configure JAX to create verified float64 arrays for higher-precision numerical work.

Read how Deep Learning with JAX explains float64 →

Also covered in

What to know first

Related concepts

Questions about float64

What is float64?

Float64 is a 64-bit floating-point numeric type, commonly represented by the IEEE 754 binary64 format.

Which Manning books explain float64?

JavaScript in Depth, Modern C, Third Edition, DuckDB in Action, 100 Java Mistakes and How to Avoid Them, Pandas Workout: 200 exercises to make you a stronger data analyst, ScyllaDB in Action, 100 Go Mistakes and How to Avoid Them and Deep Learning with JAX.

What should I know before learning float64?

Manning books that teach float64 usually introduce IEEE 754, integer, floating-point arithmetic and Map first.

What is the difference between float64 and FP32?

Float64 is a 64-bit floating-point numeric type, commonly represented by the IEEE 754 binary64 format. FP32 is a 32-bit single-precision floating-point format for representing approximate real numbers.

What is float64 a kind of?

Float64 is a kind of floating-point arithmetic. Floating-point arithmetic is numerical computation using finite-precision representations of real numbers, which can introduce rounding and range errors.

What is float64 also called?

Float64 is also called Double or 64-bit floats.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.