this is a c++ question the question is below, the file is provided, just need to add a operator.

#include <string>
#include <vector>
#include "Signal.h"

int Signal::min() const {
    int min = m_samples[0];
    for (int i = 1; i < length(); i++) {
        if (min > m_samples[i]) {
            min = m_samples[i];
        }
    }

    return min;
}

int Signal::max() const {
    // Fill in function defn
    return 0;
}

double Signal::avg() const {
    double avg = 0;
    for (int i = 0; i < length(); i++) {
        avg += m_samples[i];
    }

    return avg / length();
}

int Signal::energy() const {
    int enr = 0;
    for (int i = 0; i < length(); i++) {
        enr += m_samples[i] * m_samples[i];
    }

    return enr;
}

double Signal::mse(const Signal& sig) const {
    int size = (length() > sig.length()) ? length() : sig.length();
    double pwr = 0;
    for (int i = 0; i < size; i++) {
        double err = operator[](i) - sig[i];
        pwr += err * err;
    }

    return pwr / size;
}

Signal Signal::downSample(int factor) {
    vector<int> tmp;
    for (int i = 0; i < length(); i += factor) {
        tmp.push_back(m_samples[i]);
    }

    m_samples = tmp;

    return Signal(m_samples);
}

Signal Signal::operator+(int offset) {
    vector<int> tmp;
    for (int i = 0; i < length(); i++) {
        tmp.push_back(m_samples[i] + offset);
    }

    return Signal(tmp);
}

Signal Signal::operator+(const Signal& sig) {
    int size = (length() > sig.length()) ? length() : sig.length();
    vector<int> tmp;
    for (int i = 0; i < size; i++) {
        tmp.push_back(operator[](i) + sig[i]);
    }

    return Signal(tmp);
}

Signal Signal::operator*(int scale) {
    // Fill in function defn
    Signal sig;
    return sig;
}

Signal Signal::operator*(const Signal& sig) {
    vector<int> tmp(length() + sig.length() - 1, 0);    
    for (int i = 0; i < tmp.size(); i++) {
        for (int j = 0; j < length(); j++) {
            tmp[i] += m_samples[j] * sig[i - j];
        }
    }

    return Signal(tmp);
}

Signal Signal::operator>>(unsigned int shift) {
    vector<int> tmp;
    for (int i = 0; i < shift; i++) {
        tmp.push_back(0);
    }

    for (int i = 0; i < length(); i++) {
        tmp.push_back(m_samples[i]);
    }

    m_samples = tmp;

    return Signal(m_samples);
}

Signal Signal::operator<<(unsigned int shift) {
    vector<int> tmp;
    for (int i = shift; i < length(); i++) {
        tmp.push_back(m_samples[i]);
    }

    m_samples = tmp;

    return Signal(m_samples);
}

int Signal::operator[](int index) const {
    if (index < 0 || index >= length()) {
        return 0;
    }

    return m_samples[index];
}

Signal operator+(int offset, const Signal& sig) {
    vector<int> tmp;
    for (int i = 0; i < sig.length(); i++) {
        tmp.push_back(sig[i] + offset);
    }

    return Signal(tmp);
}

Signal operator*(int scale, const Signal& sig) {
    vector<int> tmp;
    for (int i = 0; i < sig.length(); i++) {
        tmp.push_back(sig[i] * scale);
    }

    return Signal(tmp);
}

ifstream& operator>>(ifstream& ifs, Signal& sig) {
    sig.m_samples.clear();

    string str1, str2;
    ifs >> str1 >> str2;

    while (true) {
        int idx = 0, smp = 0;
        ifs >> idx >> smp;
        if (ifs.eof()) {
            break;
        }

        sig.m_samples.push_back(smp);
    }

    return ifs;
}

ostream& operator<<(ostream& os, const Signal& sig) {
    os << "Sample\tValue" << endl;
    for (int i = 0; i < sig.length(); i++) {
        os << i << "\t" << sig[i] << endl;
    }

    return os;
}

ofstream& operator<<(ofstream& ofs, const Signal& sig) {
    ofs << "Sample\tValue" << endl;
    for (int i = 0; i < sig.length(); i++) {
        ofs << i << "\t" << sig[i] << endl;
    }

    return ofs;
}



#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

class Signal {
private:
    vector<int> m_samples;

public:
    Signal() {
        m_samples.clear();
    }

    Signal(const vector<int>& smp) :
        m_samples{smp} {
    }

    Signal(const Signal& sig) :
        m_samples{sig.m_samples} {
    }

    ~Signal() {
        m_samples.clear();
    }

    unsigned int length() const {
        return m_samples.size();
    }

    int min() const;
    int max() const;
    double avg() const;
    int energy() const;

    double mse(const Signal& sig) const; // Mean Squared Error

    Signal downSample(int factor);

    Signal operator+(int offset); // ex: sig + 2
    Signal operator+(const Signal& sig); // ex: sig1 + sig2

    Signal operator*(int scale); // ex: sig * 2
    Signal operator*(const Signal& sig); // ex: sig1 * sig2

    Signal operator>>(unsigned int shift); // ex: sig >> 2
    Signal operator<<(unsigned int shift); // ex: sig << 2

    int operator[](int index) const;

    friend ifstream& operator>>(ifstream& ifs, Signal& sig); // ex: ifs >> sig
};

Signal operator+(int offset, const Signal& sig); // ex: 3 + sig
Signal operator*(int scale, const Signal& sig);  // ex: 3 * sig

ostream& operator<<(ostream& os, const Signal& sig); // ex: cout << sig
ofstream& operator<<(ofstream& ofs, const Signal& sig); // ex: ofs << sig
#include "Signal.h"

int main(int argc, char* argv[]) {
    Signal b{{1}};
    Signal s1{{1, 2, 3, 4, 5, 4, 3, 2, 1}};
    Signal s2;

    for (int i = 0; i < s1.length(); i++) {
        Signal t = b;
        t >> i;
        t = s1[i] * t;

        s2 = s2 + t;

        if (s1 == s2) {
            if (i != s1.length() - 1) {
                cout << "Your operator==() function implementation is WRONG!" << endl;
                return -1;
            }
        } else {
            if (i == s1.length() - 1) {
                cout << "Your operator==() function implementation is WRONG!" << endl;
                return -1;
            }
        }
    }

    cout << "Your operator==() function implementation is CORRECT!" << endl;
    return 0;
}

Attachments:

• 1513152852-2.png