Question

我有以下输入：

double zmin;
double zmax;
int count;
int N; //Total number of element in result array

我想生成一个双数组序列，其中zmin为第一个值，zmax为最后一个值。但是从第二个值到最后一个值，但它应该被（zmax-zmin）/ count维持。

示例：

zmin = 1;
zmax = 10;
count = 3

预期结果：

double[] result = { 1, 4, 7, 10}

我的尝试：

double[] result = Enumerable.Repeat(zmin, N).Select(iv => (iv +(zmax-zmin)/count)).ToArray();

Answer 1

public static IEnumerable<double> Range(double min, double max, double step)
{
    double i;
    for (i=min; i<=max; i+=step)
        yield return i;

    if (i != max+step) // added only because you want max to be returned as last item
        yield return max; 
}

Answer 2

这不仅适用于数字，也适用于日期/时间更复杂的类型。

第二种方法允许提供结果选择器 - 在某些情况下很有用。

public static IEnumerable<TItem> Range<TItem>(
    TItem itemFrom, TItem itemTo, Func<TItem, TItem> itemSelector
) where TItem : IComparable
{
    // Call to the below method
    return Range(itemFrom, itemTo, itemSelector, o => o);
}

public static IEnumerable<TItem> Range<TItem, TResult>(
    TItem itemFrom, TItem itemTo, Func<TItem, TItem> itemSelector, Func<TItem, TResult> resultSelector
) where TItem : IComparable
{
    while (true)
    {
        yield return resultSelector(itemFrom);

        if ((itemFrom = itemSelector(itemFrom)).CompareTo(itemTo) > 0)
            break;
    }
}

用法：

Range(1, 10, o => o + 3);

Range(
   DateTime.Now, 
   DateTime.Now.AddYears(1), 
   o => o.AddMonths(1), 
   o => o.ToString("MMMM"));

January 
February 
March 
April 
May 
June 
July 
August 
September 
October 
November 
December 
January

Answer 3

这是对answer的现有Muhammad Hasan Khan的改进。该解决方案可以正常工作，但是随着时间的推移小数误差会累积，随着时间的推移，它会在小数位产生很多错误。

现有解决方案的第一个改进是避免像这样的错误累积，

public static IEnumerable<double> Range(double min, double max, double step)
{
    double result = min;
    for (int i = 0; result<max; i++)
    {
        result = min + (step * i);
        yield return result;
    }
}

这几乎可以解决问题，但如果您甚至想摆脱有时粘在小数点附近的污垢，您可以走得更远，

public static IEnumerable<double> Range(double min, double max, double step)
{
    double result = min;
    int decPlaces = BitConverter.GetBytes(decimal.GetBits((decimal)step)[3])[2];
    for (int i = 0; result<max; i++)
    {
        result = min + (step * i);
        yield return Math.Round(result,decPlaces);
    }
}

关于如何调用上述方法的方式，只是一个例子，

double[] Myarray = classname.Range(0, 50, 0.01).ToArray();

将为您提供具有上述参数的双精度数组。

Answer 4

比现有答案（截至2020年1月22日）还干净：

static IEnumerable<double> GetSteppedSequence(double from, double to, int numberOfSteps)
{
    if (numberOfSteps < 1)
    {
        throw new ArgumentOutOfRangeException(nameof(numberOfSteps), "Number of steps must be greater than zero.");
    }

    var stepSize = (to - from) / numberOfSteps;
    return Enumerable.Range(0, numberOfSteps + 1).Select(stepIndex => from + stepIndex * stepSize);
}

使用乘法而不是重复加法，从而避免了舍入误差。

生成具有步长值的序列

4 个答案: