You know, I think that iota saying the length is 121 isn't a problem, or an error. Floating point is inexact, correct? Who's to say `0 + 120 * 0.1` *exactly* `3.6`, or in fact, just a *little* smaller ? Multiplication can be just as inexact as division, right?

As a matter of fact, if we do it during ctfe, we get the same result (and, AFAIK, there is no rounding error during CTFE, right?):

```D
static assert(iota(0.0, 3.6, 0.03).length == 121);
```

I think the "correct" way to write the unittests would be:

```D
enum length = iota(0.0, 3.6, 0.03).length;
assert(iota(0.0, 3.6, 0.03).length == length);
```

Writing it that way, the tests all seem to pass (on my machine anyways).

Furthermore, this also passes:
```D
    foreach(e; iota(0.0, 3.6, 0.03))
        assert(e < 3.6);
```
Which also verifies that all 121 members of the iota respect the boundary constaints.

Also:
```D
     for (double e = 0.0 ; e < 3.6 ; e += 0.03)
         ++i;
     assert(i == 121);
```
No reason for iota to be any more precise than a basic for loop, is there?

So my conclusion is the code is correct, but the unittest itself is what is wrong. Let's fixup the unittests and we can get this merged?