Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

Develop a class of test spectrum generator for radio signals in C++. This class…

  1. User

    Develop a class of test spectrum generator for radio signals in C++. This class implements methods of generating frequency spectrum of signals with different modulation (implement AM and FM). The generator takes the frequency range (start and end), sample rate, signal-to-noise ratio, list of signal information: struct Signal {Modulation modulation; double power; double frequency; double bandwidth;}. To simplify the calculations, the signal spectrum is first calculated with the carrier frequency equal to zero, and then shifted to a given frequency. After all signal spectra have been generated and shifted to their corresponding carrier frequency, a white Gaussian noise of a given signal-to-noise ratio is added to the entire frequency range. The output is an array of signal frequency spectrum values in logarithmic scale.

  2. Assistant
    #include <iostream>
    #include <vector>
    #include <cmath>
    #include <random>
    #include <algorithm>
    
    enum Modulation {
      AM,
      FM
    };
    
    struct Signal {
      Modulation modulation;
      double power;
      double frequency;
      double bandwidth;
    };
    
    class TestSpectrumGenerator {
    public:
      TestSpectrumGenerator() = default;
    
      std::vector<double> generate_spectrum(const double start_frequency,
                                            const double end_frequency,
                                            const double sample_rate,
                                            const double signal_to_noise_ratio,
                                            const std::vector<Signal> &signals) {
    
          int n_samples = static_cast<int>((end_frequency - start_frequency) / sample_rate);
          std::vector<double> output(n_samples, 0.0);
    
          for (const auto &signal : signals) {
              generate_signal_spectrum(signal, start_frequency, sample_rate, output);
          }
    
          add_white_noise(output, signal_to_noise_ratio);
    
          for (auto &val : output) {
              val = 20.0 * std::log10(std::max(val, 1e-9));
          }
    
          return output;
      }
    
    private:
      void generate_signal_spectrum(const Signal &signal,
                                    double start_frequency,
                                    double sample_rate,
                                    std::vector<double> &output) {
    
          switch (signal.modulation) {
              case AM:
                  generate_AM_spectrum(signal, start_frequency, sample_rate, output);
                  break;
              case FM:
                  generate_FM_spectrum(signal, start_frequency, sample_rate, output);
                  break;
              default:
                  break;
          }
      }
    
      void generate_AM_spectrum(const Signal &signal,
                                double start_frequency,
                                double sample_rate,
                                std::vector<double> &output) {
    
          // Assuming zero carrier frequency and double sideband signal
          int lower_sideband_idx = static_cast<int>((signal.frequency - signal.bandwidth) * 2 / sample_rate);
          int upper_sideband_idx = static_cast<int>((signal.frequency + signal.bandwidth) * 2 / sample_rate);
    
          for (int i=lower_sideband_idx; i<=upper_sideband_idx; ++i) {
              output[i] += signal.power / (1 + std::abs(i - signal.frequency));
          }
      }
    
      void generate_FM_spectrum(const Signal &signal,
                                double start_frequency,
                                double sample_rate,
                                std::vector<double> &output) {
    
          // Assuming narrowband approximation
          int lower_sideband_idx = static_cast<int>((signal.frequency - signal.bandwidth) * 2 / sample_rate);
          int upper_sideband_idx = static_cast<int>((signal.frequency + signal.bandwidth) * 2 / sample_rate);
    
          for (int i=lower_sideband_idx; i<=upper_sideband_idx; ++i) {
              double bessel_coeff = std::abs(std::cos(signal.frequency * M_PI / signal.bandwidth));
              output[i] += signal.power * bessel_coeff;
          }
      }
    
      void add_white_noise(std::vector<double> &output, const double signal_to_noise_ratio) {
          std::random_device rd;
          std::mt19937 rng(rd());
          std::normal_distribution<double> dist;
    
          double noise_power = 0.0;
          for (const auto &val : output) {
              noise_power += val * val;
          }
          noise_power /= (output.size() * signal_to_noise_ratio);
    
          for (auto &val : output) {
              val += noise_power * dist(rng);
          }
      }
    };
    
    int main() {
      TestSpectrumGenerator generator;
      std::vector<Signal> signals = {
              {AM, 1.0, 100.0, 10.0},
              {FM, 2.0, 500.0, 20.0}
      };
      auto spectrum = generator.generate_spectrum(0.0, 1000.0, 2.0, 10.0, signals);
    
      for (const auto &val : spectrum) {
          std::cout << val << std::endl;
      }
    
      return 0;
    }
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.