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