diff --git a/Homework2/src/main.cc b/Homework2/src/main.cc
index 94fc779..44038c3 100644
--- a/Homework2/src/main.cc
+++ b/Homework2/src/main.cc
@@ -1,131 +1,130 @@
 #include <iostream>
 #include <string>
 #include <sstream>
 #include <fstream>
 #include "series.hh"
 #include "compute_arithmetic.hh"
 #include "compute_pi.hh"
 #include "dumper_series.hh"
 #include "print_series.hh"
 #include "write_series.hh"
 
 using namespace std;
 
 // Functions declaration
 void decide_series(Series *&new_series, string type);
 
 int main(int argc, char ** argv)
 {
     /*  // ========== TEST 1: Checking the function "compute(int N)" ==========
         compute_arithmetic  my_arithmetic;            // Object of type "compute_arithmetic"
         compute_pi          my_pi;                    // Object of type "compute_pi"
 
         cout << my_arithmetic.compute(10) << endl;    //Arithmetic series up to 10. Expected value: 55
         cout << my_pi.compute(10) << endl;            //Pi series up to 10. Expected value: 3.04936  */
 
 
     /*  // ========== TEST 2: Working with a Series pointer" ==========
         Series *SERIES1, *SERIES2;                    //Pointers of type Series
 
         SERIES1 = new compute_arithmetic();           //SERIES1 points to an object of type compute_arithmetic
         SERIES2 = new compute_pi();                   //SERIES2 points to an object of type compute_pi
 
         cout << SERIES1->compute(10) << endl;         //Arithmetic series up to 10. Expected value: 55
         cout << SERIES2->compute(10) << endl;         //Pi series up to 10. Expected value: 3.04936
 
         delete SERIES1;                               //Free up memory
         delete SERIES2;                               //Free up memory  */
 
 
 
     int N_inputs = argc;
     std::stringstream inputs;
     for (int i = 1; i < argc; ++i){
         inputs << argv[i] << " ";
     }
 
     std::string serie_type;
     std::string dump_type;
     std::string separator;
     unsigned long N; // max number of iteration entered as input
     unsigned long freq; //frequency for dumper series
     unsigned  int precision;
 
     inputs >> serie_type;
     inputs >> dump_type;
     inputs >> separator;
     inputs >> N;
     inputs >> freq;
     inputs >> precision;
 
     printf("###### User Inputs ###### \n");
     std::cout << "Serie type: " << serie_type << std::endl;
     std::cout << "Dump type: " << dump_type << std::endl;
     std::cout << "Separator type: " << separator << std::endl;
     std::cout << "Max iterations: " << N << std::endl;
     std::cout << "Dump frequency: " << freq << std::endl;
     std::cout << "Precision: " << precision << std::endl;
     printf("######################## \n");
 
     Series *ptrSeries = nullptr;
 
     // Choose series to be implemented
     decide_series(ptrSeries, serie_type);
 
 
     // Dumper and writing
     if (dump_type == "print")
     {
-        PrintSeries my_dump(*ptrSeries, N, freq);
-        my_dump.setPrecision(precision);
+        PrintSeries my_dump(*ptrSeries, N, freq, precision);
         my_dump.dump();
 
         std::string file_name = "ostream_output.txt";
         std::ofstream my_os_file;
         my_os_file.open(file_name, std::ios::out | std::ios::trunc);
         my_dump.dump(my_os_file);
         my_os_file.close();
     }
     else if (dump_type == "write")
     {
         WriteSeries my_dump(*ptrSeries, N);
         my_dump.setPrecision(precision);
         if ((separator == "comma") || (separator == "pipe")){
             my_dump.setSeparator(separator);
         }
         else{
             std::cout << "Data are written to a txt fille with a tab separator." << std::endl;
         }
 
         my_dump.dump();
     }
     else
     {
         std::cout << "Dump type does not exist" << std::endl;
         abort();
     }
 
 
 
     delete ptrSeries;
 
     return 0;
 }
 
 
 void decide_series(Series *&new_series, string type)
 {
     if (type == "arithmetic")
     {
         new_series = new compute_arithmetic();
     }
     else if (type == "pi")
     {
         new_series = new compute_pi();
     }
     else
     {
         cout<<"ERROR: Invalid series type. Please enter 'arithmetic' or 'pi'."<<endl;
         exit(0);
     }
 }
\ No newline at end of file
diff --git a/Homework2/src/print_series.cc b/Homework2/src/print_series.cc
index a0a61ca..ac58007 100644
--- a/Homework2/src/print_series.cc
+++ b/Homework2/src/print_series.cc
@@ -1,29 +1,36 @@
 #include <iostream>
 #include <cmath>
 #include <iomanip>
 #include "print_series.hh"
 
+PrintSeries::PrintSeries(Series & series, unsigned int N, unsigned int freq, unsigned int precision = 4): DumperSeries(series)
+{
+    maxiter = N;
+    frequency = freq;
+    setPrecision(precision);
+}
+
 void PrintSeries::dump(std::ostream& os)
 {
     double computed, analytical, error;
 
     for (int i = 1; i <= maxiter; i++)
     {
         if ((i-1) % frequency == 0)
         {
             computed = series.compute(i);
 
             os << i << "\t" << std::fixed << std::setprecision(dump_precision) << computed;
 
             if (!std::isnan(series.getAnalyticPrediction()))
             {
                 analytical = series.getAnalyticPrediction();
                 error = 100.0 * abs(analytical - computed) / analytical;
 
                 os << "\t" <<  std::fixed << std::setprecision(dump_precision) << analytical << "\t" << error <<" %";
             }
 
             os << std::endl;
         }
     }
 }
\ No newline at end of file
diff --git a/Homework2/src/print_series.hh b/Homework2/src/print_series.hh
index 0a78662..94566ff 100644
--- a/Homework2/src/print_series.hh
+++ b/Homework2/src/print_series.hh
@@ -1,23 +1,18 @@
 #ifndef PRINT_SERIES_HH
 #define PRINT_SERIES_HH
 
 #include "dumper_series.hh"
 
 class PrintSeries: public DumperSeries
 {
 private:
     unsigned int maxiter;
     unsigned int frequency;
 
 public:
-    PrintSeries(Series & series, unsigned int N, unsigned int freq, unsigned int precision = 4): DumperSeries(series)
-    {
-        maxiter = N;
-        frequency = freq;
-        setPrecision(precision);
-    }
+    PrintSeries(Series & series, unsigned int N, unsigned int freq, unsigned int precision);
 
     void dump(std::ostream & os = std::cout);
 };
 
 #endif
\ No newline at end of file