number ranges

[Salih Dincer]

On Thursday, 20 January 2022 at 16:33:20 UTC, Ali Çehreli wrote:
>
> So if we add the 1.0 value after 0.9000000357627869 to be 
> *inclusive*, then that last step would not be 0.3 anymore. 
> (Thinking about it, step would mess up things for integral 
> types as well; so, it must be checked during construction.)
>
> The other obvious issue in the output is that a floating point 
> iota cannot be bidirectional because the element values would 
> be different.

The test that did not pass now passes. There is the issue of 
T.min being excluded from the property list for the double type. 
I tried to solve it, how is it?

Salih

```d
auto inclusiveRange(T)(T f, T l, T s = cast(T)0)
in(!isBoolean!T) {
   static assert(!isBoolean!T, "\n
       Cannot be used with bool type\n");
   if(!s) s++;
   return InclusiveRange!T(f, l, s);
}

struct InclusiveRange(T) {
   private:
     T first, last;
     bool empty_;

   public:
     T step;

   this(U)(in U first, in U last, in U step)
   in (first <= last, format!"\n
       Invalid range:[%s,%s]."(first, last))
   {
     this.first = first;
     this.last = last;
     this.step = step;
     this.empty_ = false;
   }

   bool opBinaryRight(string op:"in")(T rhs) {
     foreach(r; this) {
       if(r == rhs) return true;
     }
     return false;
   }

   auto save() inout { return this; }
   bool empty() inout { return empty_; }
   T front() inout { return first; }
   T back() inout { return last; }

   void popFront() {
     if(!empty) {
       if(last >= first + step) {
         first += step;
       } else {
         empty_ = true;
         if(T.max <= first + step) {
           first += step;
         }
       }
     }
   }

   void popBack() {
     if(!empty) {
       if(first <= last-step) {
         last -= step;
       } else {
         empty_ = true;
         if(!T.max >= last - step) {
           last -= step;
         }
       }
     }
   }

   size_t length() inout {
     auto len = 1 + (last - first) / step;
     return cast(size_t)len;
   }
}

import std.algorithm, std.math;
import std.range, std.traits;
import std.stdio, std.format, std.conv;

void main() {
   // Pi Number Test
   auto GregorySeries = inclusiveRange!double(1, 0x1.0p+27, 2);
   double piNumber = 0;
   foreach(e, n; GregorySeries.enumerate) {
     if(e & 1) piNumber -= 1/n;
     else piNumber += 1/n;
   }
   writefln!"%.21f (constant)"(PI);
   writefln!"%.21f (calculated)"(piNumber * 4);

} unittest {
   // Should not be possible to have an empty range

   auto r = inclusiveRange(ubyte.min, ubyte.max);
   static assert(is(ElementType!(typeof(r)) == ubyte));

   assert(r.sum == (ubyte.max * (ubyte.max + 1)) / 2);
}
```