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运算符定义here，这就消除了对局部变量的需求：

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变得太高之后，你只会得到零。

Linq声明连续一半的无限序列

5 个答案: