# Chapter 12: Floats, References and Arrays

In this chapter we add a series of new types and some modest syntax.

## Floats

Floating point values start with the `flt` type and compute IEEE754 64-bit arithmetic.
Integer expressions auto-widen to floats when involved in a float expression.

```java
flt f = 0.5;
int x = 2;
f = f+x;     // Auto-widen x to 2.0, result is 2.5
f = f+true;  // Since bools are just synonyms for integers 0,1 they auto-widen also
```


Here is Newton's method to a square root:
```java
flt guess = arg;  // Initial guess is just argument
while( true ) {
    // Next guess from Newton's method
    flt next = (arg/guess + guess)/2;
    // Break if hit fixed point
    if( next == guess ) break;
    guess = next;
}
return guess;
```
When run with argument 2.0, produces 1.414213562373095.

Floating point operations have their own Nodes:

| Node                   | Op                   |
|------------------------|----------------------|
| AddF, SubF, MulF, DivF | Basic binary FP ops  |
| MinusF                 | Unary negate         |
| EQF, LTF, LEF          | FP compare operators |

And their own section in the Type lattice:

Within the Type Lattice, we now add the following domain:

* Float type - Float values.  The same shape as the Integer values, but floats
  with a TOP, BOT and constants


## References

Structs can reference other structs; references can be mutually recursive.
Any reference field can allow null or not, same as a normal variable.

```java
struct Person {
  String name;       // No string type, yet
  int age;
  FamilyTree tree?;  // A family tree, or not
}
struct FamilyTree {
  Person father?;
  Person mother?;
  Person []kids?;
}
```

Normal field syntax works:  `person.tree.father = new Person;` or `person.tree.father.name = "Dad";`.