Оператор Linq для бесконечной последовательности последовательных половинок

Question

Учитывая начальное число, представьте бесконечную последовательность его последовательных половинок.

1, 0.5, 0.25, 0.125, ...

(игнорировать любые числовые нестабильности, присущие double.)

Может ли это быть сделано в одном выражении без написания каких-либо пользовательских методов расширения или методов генератора?

Answer 1

Для забавы вот трюк для создания реальной бесконечной последовательности в одном выражении. Первые два определения являются полями класса, поэтому они не требуют инициализации выражения.

double? helper;
IEnumerable<double> infinite;

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

Answer 2

Я не знаю способа с одним выражением, но я нашел этот умный код генератора здесь: 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 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))));

Anпример использования будет:

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

, который выдаст 20, 10, 5, 2.5 и т. д.

Я бы не советовал использовать это в рабочем коде, но это весело.

Оператор Y также допускает другие рекурсивные лямбда-выражения, например:

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 станет слишком высоким.