# Work with floats

A float type represents a IEEE-754 64-bit floating-point number.

Type name: `float`

## Float syntax

A float literal contains a decimal integer, a decimal point, and a decimal fraction.

``````0.0
123.4
-123.456
``````

### Scientific notation

Flux does not support scientific notation float literal syntax. However, you can use `float()` to convert a scientific notation string into a float type.

``````1.23456e+78
// Error: error @1:8-1:9: undefined identifier e

float(v: "1.23456e+78")
// Returns 1.23456e+78 (float)
``````

### Infinity

Flux does not support infinite float literal syntax (`+Inf` and `-Inf`). However, you can use `float()` to convert a infinite string into a float type.

``````+Inf
// Error: error @1:2-1:5: undefined identifier Inf

float(v: "+Inf")
// Returns +Inf (float)
``````

### Not a Number

Flux does not support Not a Number (NaN) float literal syntax. However, you can use `float()` to convert a NaN string into a float type.

``````NaN
// Error: error @1:2-1:5: undefined identifier NaN

float(v: "NaN")
// Returns NaN (float)
``````

## Convert data types to floats

Use the `float()` function to convert the following basic types to floats:

• string: must be a numeric string or scientific notation
• bool: `true` converts to `1.0`, `false` converts to `0.0`
• int
• uint
``````float(v: "1.23")
// 1.23

float(v: true)
// Returns 1.0

float(v: 123)
// Returns 123.0
``````

### Convert columns to floats

Flux lets you iterate over rows in a stream of tables and convert columns to floats.

To convert the `_value` column to floats, use the `toFloat()` function.

`toFloat()` only operates on the `_value` column.

``````data
|> toFloat()
``````
##### Given the following input data:
_time _value (int)
2021-01-01T00:00:00Z 10
2021-01-01T02:00:00Z 20
2021-01-01T03:00:00Z 30
2021-01-01T04:00:00Z 40
##### The example above returns:
_time _value (float)
2021-01-01T00:00:00Z 10.0
2021-01-01T02:00:00Z 20.0
2021-01-01T03:00:00Z 30.0
2021-01-01T04:00:00Z 40.0

To convert any column to floats:

1. Use `map()` to iterate over and rewrite rows.
2. Use `float()` to convert columns values to floats.
``````data
|> map(fn: (r) => ({ r with index: float(v: r.index) }))
``````
##### Given the following input data:
_time index (int)
2021-01-01T00:00:00Z 1
2021-01-01T02:00:00Z 2
2021-01-01T03:00:00Z 3
2021-01-01T04:00:00Z 4
##### The example above returns:
_time index (float)
2021-01-01T00:00:00Z 1.0
2021-01-01T02:00:00Z 2.0
2021-01-01T03:00:00Z 3.0
2021-01-01T04:00:00Z 4.0

## Operate on floats

### Perform arithmetic operations on floats

To perform operations like adding, subtracting, multiplying, or dividing float values, use Flux arithmetic operators. Operands must be the same type.

``````1.23 + 45.67
// Returns 46.9

1.23 - 45.67
// Returns -44.440000000000005

float(v: "12345e+67") * 100.0
// Returns 1.2345000000000001e+73

144.0 / 12.0
// Returns 12.0

10.0 ^ 2.0
// Returns 100.0
``````

#### Inherent rounding errors in floating-point arithmetic

To fit an infinite number of real values into a finite number of bits, computer systems must round floating-point values in arithmetic operations. This results in small rounding errors in some operations.

### Compare float values

Use Flux comparison operators to compare float values. Operands must be the same type. The operation returns a float.

``````12345600.0 == float(v: "1.23456e+07")
// Returns true

1.2 > -2.1
// Returns true
``````

### Round float values

1. Import the `math` package.
2. Use `math.round()` to round to the nearest whole number.
``````import "math"

math.round(x: 1.54)
// Returns 2.0
``````

### Flux math package

Use the `math` package to perform operations on float values.