Custom Linq Range Class
using System;
using System.Collections.Generic;
using System.Numerics;
public static class LinqHelper
{
/// <summary>
/// Generates a sequence of character values within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<char> Range(char from, char to, char step = '\x0001')
{
var d = '\x0';
while((char) (from + (uint) d) < to)
{
yield return(char) (from + (uint) d);
d += step;
}
}
/// <summary>
/// Generates a sequence of 8-bit signed numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<sbyte> Range(sbyte from, sbyte to, sbyte step = 1)
{
var d = 0;
while((sbyte) (from + d) < to)
{
yield return(sbyte) (from + d);
d += step;
}
}
/// <summary>
/// Generates a sequence of 8-bit unsigned numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<byte> Range(byte from, byte to, byte step = 1)
{
var d = 0;
while((byte) (from + d) < to)
{
yield return(byte) (from + d);
d += step;
}
}
/// <summary>
/// Generates a sequence of 16-bit signed numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<short> Range(short from, short to, short step = 1)
{
var d = 0;
while((short) (from + d) < to)
{
yield return(short) (from + d);
d += step;
}
}
/// <summary>
/// Generates a sequence of 16-bit unsigned numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<ushort> Range(ushort from, ushort to, ushort step = 1)
{
var d = 0;
while((ushort) (from + d) < to)
{
yield return(ushort) (from + d);
d += step;
}
}
/// <summary>
/// Generates a sequence of 32-bit signed numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<int> Range(int from, int to, int step = 1)
{
var d = 0;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of 32-bit unsigned numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<uint> Range(uint from, uint to, uint step = 1)
{
var d = 0u;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of 64-bit signed numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<long> Range(long from, long to, long step = 1)
{
var d = 0l;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of 64-bit unsigned numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<ulong> Range(ulong from, ulong to, ulong step = 1)
{
var d = 0ul;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of arbitrarily large signed numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<BigInteger> Range(BigInteger from, BigInteger to, BigInteger step)
{
var count = to - from;
for(var i = BigInteger.Zero; i < count; i = i + step)
yield return from + i;
}
/// <summary>
/// Generates a sequence of arbitrarily large floating point precision numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<BigRational> Range(BigRational from, BigRational to, BigRational step)
{
if(step == 0)
step = 1;
var count = to - from;
for(BigRational i = 0; i < count; i = +step)
yield return from + i;
}
/// <summary>
/// Generates a sequence of single precision floating-point numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<float> Range(float from, float to, float step = 1)
{
var d = 0f;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of double precision floating-point numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<double> Range(double from, double to, double step = 1)
{
var d = 0d;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of decimal numbers within a specified range starting at
/// 'form' through 'to' with a given step value.
/// </summary>
public static IEnumerable<decimal> Range(decimal from, decimal to, decimal step = 1)
{
decimal d = 0;
while(from + d < to)
{
yield return from + d;
d += step;
}
}
/// <summary>
/// Generates a sequence of DateTime numbers within a specified range starting at
/// 'form' through 'to' with a given step value in days.
/// </summary>
public static IEnumerable<DateTime> Range(DateTime from, DateTime to, double step = 1)
{
var d = from;
while(d < to)
{
yield return d;
d = d.AddDays(step);
}
}
}