用于连续半部分的无限序列的 Linq 语句

Question

给定一个起始数，想象一下它的连续两半的无限序列。

1, 0.5, 0.25, 0.125, ...

（忽略 double 固有的任何数值不稳定性。）

是否可以在单个表达式中完成此操作，而无需编写任何自定义扩展方法或生成器方法？

Answer 1

我不知道单表达式方式，但我在这里找到了这个聪明的生成器代码： http:// /csharpindepth.com/articles/Chapter11/StreamingAndIterators.aspx

public static IEnumerable<TSource> Generate<TSource>(TSource start,
                                                  Func<TSource,TSource> step)
{
   TSource current = start;
   while (true)
   {
       yield return current;
       current = step(current);
   }
}

在您的情况下，您将使用它：

foreach (double d in Generate<double>(1, c => c / 2))
{
    ...
}

Answer 2

为了好玩，这里有一个在单个表达式中创建真正的无限序列的技巧。前两个定义是类字段，因此它们不需要初始化表达式。

double? helper;
IEnumerable<double> infinite;

infinite = new object[] { null }.SelectMany(dummy => new double[] { (helper = (helper / 2) ?? 1).Value }.Concat(infinite));

Answer 3

这是类似于 @hvd 提供的答案，但使用 Y 运算符定义 此处，这消除了对局部变量的需要：

public static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f)
{
    return t => f(Y(f))(t);
}

var halves = Y<double, IEnumerable<double>>(self => d => new[] { 0d }.SelectMany(_ => new[] { d }.Concat(self(d / 2))));

一个示例用法是：

foreach (var half in halves(20))
    Console.WriteLine(half);

它将输出 20, 10, 5, 2.5 等...

我不建议在生产代码中使用它，但它很有趣。

Y 运算符还允许其他递归 lambda 表达式，例如：

var fibonacci = Y<int, int>(self => n => n > 1 ? self(n - 1) + self(n - 2) : n);
var factorial = Y<int, int>(self => n => n > 1 ? n * self(n - 1) : n);
var hanoi = Y<int, int>(self => n => n == 1 ? 1 : 2 * self(n - 1) + 1);

Answer 4

Enumerable.Repeat(1, int.MaxValue).Select((x, i) => x / Math.Pow(2, i))

它实际上并不是无限的，但由于 Repeat 和 Select 都使用延迟执行，因此您不会损失任何性能。

不知道任何创建无限 linq 表达式的本机方法。

或者您可以手动编写无限版本的 .Repeat

Answer 5

我不知道有什么方法可以直接使用 LINQ 来创建无限序列。但您可以制作一个非常长的序列。

var sequence = Enumerable.Range(0, int.MaxValue)
                         .Select(n => Math.Pow(2, -n));

但是，由于 double 的精度有限，因此在 n 变得太高后，您只会得到零。