# Floating point values, operations, and typecasting in Arduino

#### Description

Datatype for floating-point numbers, a number that has a decimal point. Floating-point numbers are often used to approximate analog and continuous values because they have greater resolution than integers. Floating-point numbers can be as large as 3.4028235E+38 and as low as -3.4028235E+38. They are stored as 32 bits (4 bytes) of information.
Floats have only 6-7 decimal digits of precision. That means the total number of digits, not the number to the right of the decimal point. Unlike other platforms, where you can get more precision by using a double (e.g. up to 15 digits), on the Arduino, double is the same size as float.
Floating point numbers are not exact, and may yield strange results when compared. For example `6.0 / 3.0` may not equal `2.0`. You should instead check that the absolute value of the difference between the numbers is less than some small number.
Floating point math is also much slower than integer math in performing calculations, so should be avoided if, for example, a loop has to run at top speed for a critical timing function. Programmers often go to some lengths to convert floating point calculations to integer math to increase speed.

#### Examples

```    float myfloat;
float sensorCalbrate = 1.117;
```

#### Syntax

```    float var = val;
```
• var - your float variable name
• val - the value you assign to that variable

#### Example Code

```   int x;
int y;
float z;

x = 1;
y = x / 2;            // y now contains 0, ints can't hold fractions
z = (float)x / 2.0;   // z now contains .5 (you have to use 2.0, not 2)```
```//type casting
```

# Arithmetic Operations in Arduino Programming Language

## Addition, Subtraction, Multiplication, & Division

#### Description

These operators (+, -, / & *) return the sum, difference, product, & quotient (respectively) of the two operands, so they are binary operator. The operation is conducted using the data type of the operands, so, for example, `9 / 4` gives `2` since 9 and 4 are ints. This also means that the operation can overflow if the result is larger than that which can be stored in the data type (e.g. adding 1 to an int with the value 32,767 gives -32,768). If the operands are of different types, the "larger" type is used for the calculation.
If one of the numbers (operands) are of the type float or of type double, floating point math will be used for the calculation, and the integer type will be suppressed.

#### Examples

```y = y + 3;  //add
x = x - 7;  //subtract
i = j * 6;  //multiply
r = r / 5;  //divide

```

#### Syntax

```result = value1 + value2;  //add
result = value1 - value2;  //subtract
result = value1 * value2;  //multiply
result = value1 / value2;  //divide

```

#### Parameters:

value1 & value2: any variable or constant of a particular type

#### Programming Tips:

• Know that integer constants default to int, so some constant calculations may overflow (e.g. 60 * 1000 will yield a negative result, refer to the cyclic property of signed integer).
• Choose variable sizes that are large enough to hold the largest results from your calculations
• Know at what point your variable will "roll over" and also what happens in the other direction e.g. (0 - 1) OR (0 - - 32768)
• For math that requires fractions, use float variables, but be aware of their drawbacks: large size, slow computation speeds ( as they require more storage space compared to integer type & more processing power is consumed when operating them )
• Use the typecast operator e.g. (int)floating_variable to convert one variable type to another over the run time