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{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, в них циклы реструктурируются за нас).
Еще одна сложная часть — генерация сигналов. Еще раз взглянем на
gen_cosine
:
static auto gen_cosine (size_t period_len)
{
return [period_len, n{0}] () mutable {
return cos(double(n++) * 2.0 * M_PI / period_len);
};
}
Каждый экземпляр лямбда-выражения представляет собой объект функции, который изменяет свое состояние при каждом вызове. Его состояние описывается переменными
period_len
и n. Последняя изменяется с каждым вызовом. Сигнал имеет различные значения в разные моменты времени, выражение n++ описывает увеличивающиеся моменты времени. Чтобы получить сам вектор сигнала из выражения, мы создали вспомогательную функцию signal_from_generator
:
template
static auto signal_from_generator(size_t len, F gen)
{
csignal r (len);
generate(begin(r), end(r), gen);
return r;
}
Эта вспомогательная функция выделяет память для вектора сигнала с заданной длиной и вызывает метод
std::generate
, что позволяет заполнить точки его графика. Для каждого элемента вектора r
он один раз вызывает объект функции gen
, который представляет собой самоизменяющийся объект функции; его можно создать с помощью gen_cosine
.
К сожалению, способ решения задачи с помощью STL не позволяет сделать код более элегантным. Ситуация может измениться, если библиотека
ranges
будет включена в клуб STL (надо надеяться, что это случится в C++20). Определяем ошибку суммы двух векторов
Существует несколько способов определения численной ошибки между целевым и реальным значениями. Измерение разницы между сигналами, состоящими из множества точек графика, обычно подразумевает использование циклов и вычитание соответствующих точек графика и т.д.
Существует простая формула для определения этой ошибки между сигналами
a
и b
(рис. 6.5).Для каждого значения
i
мы вычисляем a[i]–b[i], возводим разность в квадрат (таким образом, получаем возможность сравнить положительные и отрицательные значения) и, наконец, складываем эти значения. Опять же мы могли бы просто воспользоваться циклом, но ради интереса сделаем это с помощью алгоритма STL. Плюс данного подхода заключается в том, что мы не зависим от структуры данных. Наш алгоритм будет работать для векторов и для спископодобных структур данных, для которых нельзя выполнить прямое индексирование.
Как это делается
В этом примере мы создадим два сигнала и посчитаем для них ошибку суммы.
1. Как и обычно, сначала приводим выражения
include
. Затем объявляем об использовании пространства имен std
:
#include
#include
#include
#include