## Friday, March 22, 2013

### Sasa.Numbers - Generic Number Extensions

This is the sixth post in my ongoing series covering the abstractions in Sasa. Previous posts:

The Sasa.Numbers static class provides a number of useful extensions methods on all of the CLR's number types. It is available in the core Sasa.dll.

## Sasa.Numbers.UpTo

Generating a sequence of numbers is a pretty common operation in programming, so there's a special overload extension called Sasa.Numbers.UpTo:

```// iseq = 1, 2, 3
IEnumerable<int> iseq = 1.UpTo(end: 4);
// iseq2 = 1, 3, 5, 7
IEnumerable<int> iseq2 = 1.UpTo(end: 8, step: 2);
// dseq = 5.0, 5.5, 6.0, 6.5, 7.0
IEnumerable<double> dseq = 5.0.UpTo(end: 7.5, step: 0.5);```

The simplest overload simply takes the inclusive lower and exclusive upper bounds for the sequence, and the second overload additionally takes a step size designating the increment between each number emitted.

These are defined as generic methods which make use of Sasa.Operators<T>, Sasa's generic operators class.

## Sasa.Numbers.DownTo

Sasa.Numbers.DownTo is the complement to Sasa.Numbers.UpTo, where instead of generating a sequence of increasing numbers, it generates a sequence of decreasing numbers:

```// iseq = 4, 3, 2
IEnumerable<int> iseq = 4.DownTo(end: 1);
// iseq2 = 8, 6, 4, 2
IEnumerable<int> iseq2 = 8.DownTo(end: 1, step: 2);
// dseq = 7.5, 7.0, 6.5, 6.0, 5.5
IEnumerable<double> dseq = 7.5.DownTo(end: 5.0, step: 0.5);```

The simplest overload simply takes the inclusive upper and exclusive lower bounds for the sequence, and the second overload additionally takes a step size designating the decrement between each number emitted.

These are defined as generic methods which make use of Sasa.Operators<T>, Sasa's generic operators class.

## Sasa.Numbers.Bound

The Sasa.Numbers.Bounds extension method ensures that a value falls between lower and upper inclusive limits:

```int x = 3.Bound(0, 5);          // x=3
int y = 99.Bound(0, 5);         // y=5
double z = 3.0.Bound(4.4, 5.7); // z=4.4```

This is defined as a generic method which makes use of Sasa.Operators<T>, Sasa's generic operators class.

## Sasa.Numbers.Max

The Sasa.Numbers.Max extension method returns the larger between two arguments it's given:

```int x = Numbers.Max(3, 88);        // x=88
decimal d = Numbers.Max(234M, 8M); // d=234M```

This is defined as a generic method which makes use of Sasa.Operators<T>, Sasa's generic operators class.

## Sasa.Numbers.Min

The complement to Max, the Sasa.Numbers.Min extension method returns the smaller of two arguments:

```int x = Numbers.Min(3, 88);        // x=3
decimal d = Numbers.Min(234M, 8M); // d=8M```

This is defined as a generic method which makes use of Sasa.Operators<T>, Sasa's generic operators class.

## Sasa.Numbers.ToSentence

The Sasa.Numbers.ToSentence method converts an integer to its English sentence representation:

```var list = new[] { 3, 99, -99, int.MinValue };
foreach (var x in list)
{
Console.WriteLine(Numbers.ToSentence(x));
}
// outputs:
// Three
// Ninety Nine
// Minus Ninety Nine
// Minus Two Billion One Hundred Fourty Seven Million Four Hundred Eighty Three Thousand Six Hundred Fourty Eight
```