Filters and Sequences Coursework

#include <iostream>
#include <fstream>
#include <stdlib.h>

using namespace std;

class sequence
{
    public:
        sequence(const int NUMBER_OF_SAMPLES=4);      //takes the number of samples in the sequence and generates an appropriate array with it
        sequence(const int _number_of_samples,float* _Sample_Values);
        sequence(ifstream& data_input);
        ~sequence();
        sequence(const sequence& old_sequence);
        const sequence& operator=(const sequence& first_sequence);
        const sequence operator+(const sequence& sequence_being_added);
        const sequence& operator+=(const sequence& sequence_being_added);
        float get_value_of_THE_sample(const int Which_sample);
        void set_value_of_THE_sample(const int Which_sample,const float Value_sample);
        void set_values_of_samples_to_zero();
        int get_number_of_samples();
        friend istream& operator>>(istream& input_stream, sequence& new_sequence);
        friend ostream& operator<<(ostream& output_stream,sequence& the_sequence);
    private:
        int number_of_samples;
        float* Sample_Values;
};

sequence::sequence(int NUMBER_OF_SAMPLES):number_of_samples(NUMBER_OF_SAMPLES)
{
    if(NUMBER_OF_SAMPLES<0)
    {
        cout<<"Not a valid value!";
    }
    else
    {
        Sample_Values= new float[number_of_samples];
    }
}

sequence::sequence(const int _number_of_samples,float* _Sample_Values):number_of_samples(_number_of_samples)
{
    if(_number_of_samples<0)
    {
        cout<<"Not a valid value!";
    }
    else
    {
        Sample_Values= new float[number_of_samples];
        int i=0;
        for(i; i<number_of_samples; i++)
        {
            Sample_Values[i]=_Sample_Values[i];
        }
    }

}

sequence::sequence(ifstream& data_input)
{
    if(!data_input.is_open())
    {
        exit (0);
    }
    else
    {
        data_input>>number_of_samples;
        Sample_Values= new float[number_of_samples];
        int i=0;
        for(i; i<number_of_samples; i++)
        {
            data_input>>Sample_Values[i];
        }
    }
}

sequence::~sequence()
{}

float sequence::get_value_of_THE_sample(const int Which_sample)
{
    if(Which_sample<number_of_samples&&Which_sample>=0)
    {
        return(Sample_Values[Which_sample]);
    }
    else
    {
        exit (0);
    }
}

sequence::sequence(const sequence& old_sequence):number_of_samples(old_sequence.number_of_samples)
{

    Sample_Values=new float[number_of_samples];
    for(int i=0;i<number_of_samples;i++)
    {
        Sample_Values[i]=old_sequence.Sample_Values[i];
    }
}

const sequence& sequence::operator=(const sequence& first_sequence)
{
    if(this==&first_sequence)
    {
        return(*this);
    }
    if(number_of_samples!=first_sequence.number_of_samples)
    {
        number_of_samples=first_sequence.number_of_samples;
        delete[] Sample_Values;
        Sample_Values=new float[number_of_samples];
    }
    for(int i=0;i<number_of_samples;i++)
    {
        Sample_Values[i]=first_sequence.Sample_Values[i];
    }
}

const sequence sequence::operator+(const sequence& sequence_being_added)
{
    sequence sum_of_sequences;
    sum_of_sequences.number_of_samples=number_of_samples+sequence_being_added.number_of_samples;
    sum_of_sequences.Sample_Values=new float[sum_of_sequences.number_of_samples];
    int i;
    for(i=0;i<number_of_samples;i++)
    {
        sum_of_sequences.Sample_Values[i]=Sample_Values[i];
    }
    for(int j=0;j<sequence_being_added.number_of_samples;j++)
    {
        sum_of_sequences.Sample_Values[i]=sequence_being_added.Sample_Values[j];
        i++;
    }
    return(sum_of_sequences);
}

const sequence& sequence::operator+=(const sequence& sequence_being_added)
{
    *this=*this + sequence_being_added;
    return (*this);
}


void sequence::set_value_of_THE_sample(int Which_sample,float Value_sample)
{
    if(Which_sample<number_of_samples&&Which_sample>=0)
    {
        Sample_Values[Which_sample]=Value_sample;
    }
    else
    {
        exit (0);
    }
}

int sequence::get_number_of_samples()
{
    return (number_of_samples);
}

void sequence::set_values_of_samples_to_zero()
{
    int i=0;
    for(i;i<number_of_samples;i++)
    {
        Sample_Values[i]=0;
    }
}

istream& operator>>(istream& input_stream, sequence& new_sequence)
{
    input_stream>>new_sequence.number_of_samples;
    new_sequence.Sample_Values=new float[new_sequence.number_of_samples];
    for(int i=0;i<new_sequence.number_of_samples;i++)
    {
        input_stream>>new_sequence.Sample_Values[i];
    }
    return (input_stream);
}

ostream& operator<<(ostream& output_stream,sequence& the_sequence)
{
    output_stream<<"\n the number of samples is:"<<the_sequence.number_of_samples;
    for(int i=0;i<the_sequence.number_of_samples;i++)
    {
        output_stream<<"\n Sample "<<i<<" has a value of:"<<the_sequence.Sample_Values[i];
    }
    return(output_stream);
}

class FIR
{
    public:
        FIR(const int _number_of_coefficients=1);
        FIR(const int _number_of_coefficients,float* _Filtered_Coefficients);
        FIR(ifstream& data_input);
        ~FIR();
        FIR(const FIR& old_FIR);
        const FIR& operator=(const FIR& first_FIR);
        float get_value_of_THE_coefficient(const int Which_coefficient);
        void set_value_of_THE_coefficient(const int Which_coefficient,const float Value_coefficient);
        friend istream& operator>>(istream& input_stream, FIR& new_FIR);
        friend ostream& operator<<(ostream& output_stream, FIR& the_FIR);

        sequence apply_filter(sequence& _sequence_to_be_filtered);
    private:
        int number_of_coefficients;
        float* Filtered_Coefficients;
};

FIR::FIR(const int _number_of_coefficients):number_of_coefficients(_number_of_coefficients)
{
    if(_number_of_coefficients<0)
    {
        cout<<"Not a valid value!";
    }
    else
    {
        Filtered_Coefficients= new float[number_of_coefficients];
    }
}

FIR::FIR(const int _number_of_coefficients,float* _Filtered_Coefficients):number_of_coefficients(_number_of_coefficients)
{
    if(_number_of_coefficients<0)
    {
        cout<<"Not a valid value!";
    }
    else
    {
        Filtered_Coefficients= new float[number_of_coefficients];
        int i=0;
        for(i; i<number_of_coefficients; i++)
        {
            Filtered_Coefficients[i]=_Filtered_Coefficients[i];
        }
    }

}

FIR::FIR(ifstream& data_input)
{
    if(!data_input.is_open())
    {
        exit (0);
    }
    else
    {
        data_input>>number_of_coefficients;
        Filtered_Coefficients= new float[number_of_coefficients];
        int i=0;
        for(i; i<number_of_coefficients; i++)
        {
            data_input>>Filtered_Coefficients[i];
        }
    }
}

FIR::~FIR()
{

}

FIR::FIR(const FIR& old_FIR):number_of_coefficients(old_FIR.number_of_coefficients)
{
    Filtered_Coefficients=new float[number_of_coefficients];
    for(int i=0;i<number_of_coefficients;i++)
    {
        Filtered_Coefficients[i]=old_FIR.Filtered_Coefficients[i];
    }
}

const FIR& FIR::operator=(const FIR& first_FIR)
{
    if(this==&first_FIR)
    {
        return(*this);
    }
    if(number_of_coefficients!=first_FIR.number_of_coefficients)
    {
        number_of_coefficients=first_FIR.number_of_coefficients;
        delete[] Filtered_Coefficients;
        Filtered_Coefficients=new float[number_of_coefficients];
    }
    for(int i=0;i<number_of_coefficients;i++)
    {
        Filtered_Coefficients[i]=first_FIR.Filtered_Coefficients[i];
    }
}

float FIR::get_value_of_THE_coefficient(const int Which_coefficient)
{
    if(Which_coefficient<number_of_coefficients&&Which_coefficient>=0)
    {
        return(Filtered_Coefficients[Which_coefficient]);
    }
    else
    {
        exit (0);
    }
}

void FIR::set_value_of_THE_coefficient(const int Which_coefficient,const float Value_coefficient)
{
    if(Which_coefficient<number_of_coefficients&&Which_coefficient>=0)
    {
        Filtered_Coefficients[Which_coefficient]=Value_coefficient;
    }
    else
    {
        exit (0);
    }
}

istream& operator>>(istream& input_stream, FIR& new_FIR)

{
    {
        input_stream>>new_FIR.number_of_coefficients;
        new_FIR.Filtered_Coefficients=new float[new_FIR.number_of_coefficients];
        for(int i=0; i<new_FIR.number_of_coefficients; i++)
        {
            input_stream>>new_FIR.Filtered_Coefficients[i];
        }
        return (input_stream);
    }

}

ostream& operator<<(ostream& output_stream, FIR& the_FIR)
{
    output_stream<<"\n the number of coefficients is:"<<the_FIR.number_of_coefficients;
    for(int i=0;i<the_FIR.number_of_coefficients;i++)
    {
        output_stream<<"\n Filtered coefficient "<<i<<" has a value of:"<<the_FIR.Filtered_Coefficients[i];
    }
    return(output_stream);
}

sequence FIR::apply_filter(sequence& _sequence_to_be_filtered) //it won't work with const sequence& _blabla
{
    int number_of_samples_of_sequence_to_be_filtered=_sequence_to_be_filtered.get_number_of_samples(),filtered_number_of_samples=number_of_samples_of_sequence_to_be_filtered+number_of_coefficients-1;
    sequence filtered_sequence(filtered_number_of_samples);
    float filtered_sample;
    for(int i=0; i<filtered_number_of_samples; i++)
    {
        filtered_sample=0;
        for(int j=0; j<=i; j++)
        {
            if(j<number_of_coefficients&&i-j<number_of_samples_of_sequence_to_be_filtered)
            {
                filtered_sample+=Filtered_Coefficients[j]*_sequence_to_be_filtered.get_value_of_THE_sample(i-j);
            }
            else
            {
                filtered_sample+=0;
            }
        }
        filtered_sequence.set_value_of_THE_sample(i,filtered_sample);
    }
    return(filtered_sequence);
}

int main()
{
    ifstream filter1_input("filter1.txt");  // don't forget to copy the files inside your project folder!!!
    ifstream filter2_input("filter2.txt");
    ifstream input1_input("input1.txt");
    ifstream input2_input("input2.txt");
    FIR filter_1(filter1_input),filter_2(filter2_input);
    sequence sequence1(input1_input),sequence2(input2_input),filtered_sequence;
    filtered_sequence=filter_2.apply_filter(sequence2);
    cout<<filtered_sequence;
    ofstream filtered_data("output.txt");
    filtered_data<<filtered_sequence;
    return 0;
}