class="code">                      num_iterator{s.size()},

                      cmplx{},

                      sum_up(j))

    /div;

  });

8. До этого момента мы не выполняли код самого преобразования Фурье. Мы лишь подготовили множество вспомогательного кода, который сейчас и задействуем. Вызов std::transform сгенерирует значения j = 0...N для внешнего цикла. Преобразованные значения будут помещены в вектор t, который мы и вернем вызывающей стороне:

  transform(num_iterator{0}, num_iterator{s.size()},

            begin(t), to_ft);

  return t;

}

9. Реализуем отдельные функции, которые позволяют создать объекты функций для генерации сигналов. Первая из них представляет собой генератор косинусоидального сигнала. Она возвращает лямбда-выражение, способное сгенерировать косинусоидальный сигнал на основе заданной длины периода. Сам сигнал может иметь произвольную длину, но его длина периода будет фиксированной. Длина периода N означает, что сигнал повторит себя спустя N шагов. Лямбда-выражение не принимает никаких параметров. Можно постоянно вызывать его, и для каждого вызова оно будет возвращать точку графика сигнала для следующего момента времени.

static auto gen_cosine (size_t period_len){

  return [period_len, n{0}] () mutable {

    return cos(double(n++) * 2.0 * M_PI / period_len);

  };

}

10. Вторым сигналом будет прямоугольная волна. Она колеблется между значениями –1 и +1 и не имеет других значений. Формула выглядит сложной, но она попросту преобразует линейное увеличивающееся значение n в +1 или –1, а изменяющаяся длина периода равна period_len.

Обратите внимание: в этот раз мы инициализируем n значением, не равным 0. Таким образом, наша прямоугольная волна начинается в фазе, где ее выходные значения начинаются с +1.

static auto gen_square_wave (size_t period_len)

{

  return [period_len, n{period_len*7/4}] () mutable {

    return ((n++ * 2 / period_len) % 2) * 2 - 1.0;

  };

}

11. Сгенерировать сам сигнал с помощью указанных генераторов можно, выделив память для нового вектора и заполнив его значениями, сгенерированными на основе повторяющихся вызовов функции-генератора. Это делает функция std::generate. Она принимает пару итераторов (начальный и конечный) и функцию-генератор. Для каждой корректной позиции итератора она выполняет операцию *it = gen(). Обернув данный код в функцию, мы легко сможем сгенерировать векторы сигналов.

template <typename F>

static csignal signal_from_generator(size_t len, F gen)

{

  csignal r (len);

  generate(begin(r), end(r), gen);

  return r;

}

12. В самом конце нужно вывести на экран полученные сигналы. Можно легко вывести сигнал, скопировав его значения в итератор вывода потока, но сначала следует преобразовать данные, поскольку точки графиков наших сигналов представляют собой пары комплексных значений. К этому моменту требуется только действительная часть каждой точки графика; так что помещаем значения в вызов std::transform, который извлекает лишь эту часть:

static void print_signal (const csignal &s)

{

  auto real_val ([](cmplx c) { return c.real(); });

  transform(begin(s), end(s),

            ostream_iterator<double>{cout, " "}, real_val);

  cout << 'n';

}

13. Мы реализовали формулу Фурье, но у нас еще нет сигналов для преобразования. Создаем их в функции main. Сначала определим стандартную длину сигнала, которой будут соответствовать все создаваемые сигналы:

int main()

{

  const size_t sig_len {100};

14. Теперь сгенерируем сигналы, преобразуем их и выведем на экран — это произойдет на трех следующих шагах. Первый шаг — генерация косинусоидального и прямоугольного сигналов. Они имеют одинаковые длину сигнала и длину периода:

  auto cosine (signal_from_generator(sig_len,

         gen_cosine( sig_len / 2)));

  auto square_wave (signal_from_generator(sig_len,

         gen_square_wave(sig_len / 2)));

15. Теперь у нас есть сигналы, представляющие собой косинусоидальную функцию и прямоугольную волну. Чтобы сгенерировать третий сигнал, который будет находиться между ними, возьмем сигнал прямоугольной волны и определим его преобразование Фурье (сохраним его в векторе trans_sqw). Преобразование Фурье для прямоугольной волны имеет характерную форму, мы несколько изменим ее. Все элементы с позиций от 10 до (signal_length-10) имеют значение 0.0. Остальные элементы остаются неизменными. Трансформация этого измененного преобразования Фурье обратно к представлению времени сигнала даст другой сигнал. В конце мы увидим, как он выглядит.

  auto trans_sqw (fourier_transform(square_wave));

  fill (next(begin(trans_sqw), 10), prev(end(trans_sqw), 10), 0);

  auto mid (fourier_transform(trans_sqw, true));

16. Теперь у нас есть три сигнала: cosine, mid и square_wave. Для каждого из них теперь выведем сам сигнал и его преобразование Фурье. На выходе программы увидим шесть очень длинных строк, содержащих значения типа double:

 print_signal(cosine);

 print_signal(fourier_transform(cosine));

 print_signal(mid);

 print_signal(trans_sqw);

 print_signal(square_wave);

 print_signal(fourier_transform(square_wave));

17. Компиляция и запуск программы приведут к тому, что экран консоли будет заполнен множеством численных значений. Если мы построим график для полученного результата, то увидим следующее изображение (рис. 6.4).

Как это работает 

Программа состоит из двух сложных фрагментов. Один из них — само преобразование Фурье, а другой — генерация сигналов с помощью изменяемых лямбда-выражений.

Сначала сконцентрируемся на преобразовании Фурье. Основа реализации формулы, созданной с применением циклов (которой мы не пользовались, а лишь рассмотрели во введении), выглядит так:

for (size_t k {0}; k < s.size(); ++k) {

  for (size_t j {0}; j < s.size(); ++j) {

    t[k] += s[j] * polar(1.0, pol * k * j / double(s.size()));

  }

}

С помощью алгоритмов STL std::transform и std::accumulate мы написали код, который можно подытожить, используя следующий псевдокод:

transform(num_iterator{0}, num_iterator{s.size()}, ...

  accumulate((num_iterator0}, num_iterator{s.size()}, ...

    c + s[k] * polar(1.0, pol * k * j / double(s.size()));

Мы получим точно такой же результат, что и в случае с циклом. Это, вероятно, пример ситуации, когда строгое следование алгоритмам STL не приводит к повышению качества кода. Тем не менее данная реализация алгоритма не знает о выбранной структуре данных. Она также будет работать со списками (однако в нашем случае это не будет иметь особого смысла). Еще одним преимуществом является тот факт, что алгоритмы C++17 STL легко распараллелить (данный вопрос мы рассмотрим в другой главе книги). А вот обычные циклы нужно реструктурировать, чтобы включить поддержку многопроцессорного режима (если только мы не используем внешние библиотеки наподобие OpenMP, в них циклы реструктурируются за нас).

Еще одна