7

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

1, 0.5, 0.25, 0.125, ...

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

这可以在单个表达式中完成而不编写任何自定义扩展方法或生成器方法吗？

4

5 回答 5

11

我不知道单一表达式的方式，但我在这里找到了这个聪明的生成器代码：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))
{
    ...
}
于 2012-02-22T17:21:08.093 回答
10

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

double? helper;
IEnumerable<double> infinite;

infinite = new object[] { null }.SelectMany(dummy => new double[] { (helper = (helper / 2) ?? 1).Value }.Concat(infinite));
于 2012-02-22T17:54:53.543 回答
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);
于 2012-02-23T01:30:10.100 回答
2 
Enumerable.Repeat(1, int.MaxValue).Select((x, i) => x / Math.Pow(2, i))

它实际上不是无限的，但由于两者都Repeat使用Select延迟执行，您不会失去任何性能。

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

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

于 2012-02-22T17:30:24.910 回答
1

我不知道有什么方法可以用直接 LINQ 制作无限序列。但是你可以制作一个很长的序列。

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

但是，由于具有有限的精度，所以在太高double之后你只会得到零。n

于 2012-02-22T19:16:07.197 回答