Library 3

added menu

librerie/exercise3/main.cpp

@@ -12,6 +12,5 @@
 int main() {
   std::cout << "Lasd Libraries 2020" << std::endl;
   menu();
-  lasdtest(); // To call in the menu of your library test!
   return 0;
 }

librerie/exercise3/zmytest/test.cpp

@@ -1,2 +1,419 @@
 
-// ...
+#include"test.hpp"
+#include<iostream>
+#include<random>
+#include<cmath>
+#include "../zlasdtest/test.hpp"
+
+using namespace lasd;
+
+void menu(){
+
+  unsigned short int choice;
+
+  DataType chosenDataType;
+  Implementation chosenImplementation;
+
+  do{
+    std::cout<<"1. Use your tests (to be used by the professor)"<<std::endl;
+    std::cout<<"2. Use the library demo"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+  }while(choice!=1 && choice!=2);
+  switch(choice){
+    case 1:
+      lasdtest();
+      break;
+    case 2:
+      chosenImplementation = ChooseImplementation();
+      chosenDataType = ChooseDataType();
+      UseChosenType(chosenImplementation, chosenDataType);
+      break;
+  }
+}
+
+DataType ChooseDataType(){
+  unsigned short int choice;
+  do{
+    std::cout<<"\nChoose a data type:"<<std::endl;
+    std::cout<<"1. Integer"<<std::endl;
+    std::cout<<"2. Float"<<std::endl;
+    std::cout<<"3. String"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+  }while(!(choice>0 && choice<4));
+  if(choice==1)
+    return DataType::integer;
+  else if(choice==2)
+    return DataType::ffloat;
+  else if(choice==3)
+    return DataType::sstring;
+}
+Implementation ChooseImplementation(){
+  unsigned short int choice;
+  do{
+    std::cout<<"\nChoose an implementation for the binary tree:"<<std::endl;
+    std::cout<<"1. Vector"<<std::endl;
+    std::cout<<"2. Pointers"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+  }while(!(choice>0 && choice<3));
+  if(choice==1)
+    return Implementation::vector;
+  else if(choice==2)
+    return Implementation::pointers;
+}
+
+void UseChosenType(Implementation chosenImplementation, DataType chosenDataType){
+
+  if(chosenImplementation == Implementation::vector){
+    if(chosenDataType == DataType::integer){
+      BinaryTreeVec<int> bt;
+      bt = GenerateIntegerBT(bt);
+      IntegerFunctions(bt);
+
+    }else if(chosenDataType == DataType::ffloat){
+      BinaryTreeVec<float> bt;
+      bt = GenerateFloatBT(bt);
+      FloatFunctions(bt);
+
+    }else if(chosenDataType == DataType::sstring){
+      BinaryTreeVec<string> bt;
+      bt = GenerateStringsBT(bt);
+      StringFunctions(bt);
+    }
+  }else if(chosenImplementation == Implementation::pointers){
+    if(chosenDataType == DataType::integer){
+      BinaryTreeLnk<int> bt;
+      bt = GenerateIntegerBT(bt);
+      IntegerFunctions(bt);
+
+    }else if(chosenDataType == DataType::ffloat){
+      BinaryTreeLnk<float> bt;
+      bt = GenerateFloatBT(bt);
+      FloatFunctions(bt);
+
+    }else if(chosenDataType == DataType::sstring){
+      BinaryTreeLnk<string> bt;
+      bt = GenerateStringsBT(bt);
+      StringFunctions(bt);
+    }
+  }
+}
+
+template <typename T>
+void IntegerFunctions(T& bt){
+  unsigned short int choice;
+  do{
+    std::cout<<std::endl<<std::endl;
+    std::cout<<"Choose one of the following options:"<<std::endl;
+    std::cout<<"1. Print tree"<<std::endl;
+    std::cout<<"2. Check exsistence of an element"<<std::endl;
+    std::cout<<"3. Product of integers less than 'n' "<<std::endl;
+    std::cout<<"4. Multiply each element by 3"<<std::endl;
+    std::cout<<"5. Go back"<<std::endl;
+    std::cout<<"6. Quit"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+    std::cout<<std::endl;
+    switch(choice){
+      case 1:
+        PrintTree(bt);
+        break;
+      case 2:
+        CheckExistence(bt);
+        break;
+      case 3:
+        ProductsElementsLessThan(bt);
+        break;
+      case 4:
+        MultiplyByThree(bt);
+        break;
+      case 5:
+        menu();
+        break;
+    }
+  }while(choice!=5 && choice!=6);
+}
+
+template <typename T>
+void FloatFunctions(T& bt){
+  unsigned short int choice;
+  do{
+    std::cout<<std::endl<<std::endl;
+    std::cout<<"Choose one of the following options:"<<std::endl;
+    std::cout<<"1. Print tree"<<std::endl;
+    std::cout<<"2. Check exsistence of an element"<<std::endl;
+    std::cout<<"3. Sum of floats greater than 'n' "<<std::endl;
+    std::cout<<"4. Cube elements"<<std::endl;
+    std::cout<<"5. Go back"<<std::endl;
+    std::cout<<"6. Quit"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+    std::cout<<std::endl;
+    switch(choice){
+      case 1:
+        PrintTree(bt);
+        break;
+      case 2:
+        CheckExistence(bt);
+        break;
+      case 3:
+        SumElementsGreaterThan(bt);
+        break;
+      case 4:
+        CubeElements(bt);
+        break;
+      case 5:
+        menu();
+        break;
+    }
+  }while(choice!=5 && choice!=6);
+}
+
+template <typename T>
+void StringFunctions(T& bt){
+  unsigned short int choice;
+  do{
+    std::cout<<std::endl<<std::endl;
+    std::cout<<"Choose one of the following options:"<<std::endl;
+    std::cout<<"1. Print tree"<<std::endl;
+    std::cout<<"2. Check exsistence of an element"<<std::endl;
+    std::cout<<"3. Concatenate strings whose dimension is less or equal than 'n' "<<std::endl;
+    std::cout<<"4. Head concatenation of a string"<<std::endl;
+    std::cout<<"5. Go back"<<std::endl;
+    std::cout<<"6. Quit"<<std::endl;
+    std::cin>>std::ws;
+    std::cin>>choice;
+    std::cout<<std::endl;
+    switch(choice){
+      case 1:
+        PrintTree(bt);
+        break;
+      case 2:
+        CheckExistence(bt);
+        break;
+      case 3:
+        ConcatLessThan(bt);
+        break;
+      case 4:
+        HeadConcat(bt);
+        break;
+      case 5:
+        menu();
+        break;
+    }
+  }while(choice!=5 && choice!=6);
+}
+
+/* ----- integer functions ----- */
+template <typename T>
+void ProductsElementsLessThan(T& tree){
+  int n, acc=1;
+  void (*func)(const int&, const void*, void*) = AccumulateProduct;
+
+  cout<<"Multipy all elements of the tree whose value is less than ";
+  cin>>ws>>n;
+
+  tree.FoldBreadth(func, (void*)&n, (void*)&acc);
+  cout<<"\nThe result is "<<acc<<endl<<endl;
+
+}
+void AccumulateProduct(const int& data, const void* par, void* acc){
+  if(data < (*(int*)par)){
+      *(int*)acc *= data;
+  }
+}
+
+template <typename T>
+void MultiplyByThree(T& tree){
+  void (*fun)(int&, void*) = MultiplyAnElement;
+  int par = 3;
+  tree.MapBreadth(fun,(void*)&par);
+  cout<<"The tree is:\n\n";
+  PrintTree(tree);
+}
+void MultiplyAnElement(int& data, void* par){
+  data *= *(int*)par;
+}
+
+/* ----- float functions ----- */
+template <typename T>
+void SumElementsGreaterThan(T& tree){
+  float n, acc = 0;
+  void (*func)(const float&, const void*, void*) = AccumulateSum;
+
+  cout<<"Sum all elements of the tree whose value is greater than ";
+  cin>>ws>>n;
+
+  tree.FoldBreadth(func, (void*)&n, (void*)&acc);
+  cout<<"\nThe result is "<<acc<<endl<<endl;
+}
+void AccumulateSum(const float& data, const void* par, void* acc){
+  if(data > (*(float*)par)){
+      *(float*)acc += data;
+  }
+}
+
+template <typename T>
+void CubeElements(T& tree){
+  void (*fun)(float&, void*) = Exponentiation;
+  float par = 3;
+  tree.MapBreadth(fun,(void*)&par);
+  cout<<"The tree is:\n\n";
+  PrintTree(tree);
+}
+void Exponentiation(float& data, void* par){
+  data = pow(data , *(float*)par );
+}
+
+/* ----- string functions ----- */
+template <typename T>
+void ConcatLessThan(T& tree){
+  int n;
+  string concatenated = "";
+  void (*func)(const string&, const void*, void*) = ConcatAString;
+
+  cout<<"Concatenate all elements of the tree whose length is less or equal than ";
+  cin>>ws>>n;
+
+  tree.FoldBreadth(func, (void*)&n, (void*)&concatenated);
+  cout<<"\nThe result is "<< concatenated << endl << endl;
+}
+void ConcatAString(const string& data, const void* par, void* acc){
+  if( ((int)data.length()) <= ((*(int*)par)) ){
+    *(string*)acc = *(string*)acc + "-" + data;
+  }
+}
+
+template <typename T>
+void HeadConcat(T& tree){
+  void (*fun)(string&, void*) = HeadConcatMapAux;
+  string par;
+
+  cout<<"Concatenate in front the following string: ";
+  cin>>ws;
+  cin>>par;
+
+  tree.MapBreadth(fun,(void*)&par);
+  cout<<"The tree is:\n\n";
+  PrintTree(tree);
+}
+void HeadConcatMapAux(string& data, void* par){
+  data = *(string*)par + data;
+}
+
+/* ----- shared functions ----- */
+template <template <typename...> class Tree, typename DTType>
+void PrintTree(Tree<DTType>& tree){
+  void (*PrinterFunction) (DTType&, void*) = PrintSingleElement;
+
+  cout<<"Pre order:\n";
+  tree.MapPreOrder(PrinterFunction, nullptr);
+  cout<<endl<<endl;
+
+  cout<<"In oder:\n";
+  tree.MapInOrder(PrinterFunction, nullptr);
+  cout<<endl<<endl;
+
+  cout<<"Post order\n";
+  tree.MapPostOrder(PrinterFunction, nullptr);
+  cout<<endl<<endl;
+
+  cout<<"Breadth order\n";
+  tree.MapBreadth(PrinterFunction, nullptr);
+  cout<<endl<<endl;
+}
+
+template <typename Data>
+void PrintSingleElement(Data& data, void* _){
+  std::cout << data << " ";
+}
+
+template <template <typename...> class Tree, typename DTType>
+void CheckExistence(Tree<DTType>& tree){
+  DTType elementToLookFor;
+  cout<<"\n\nCheck existence in the tree of: ";
+  cin>>ws;
+  cin>>elementToLookFor;
+  cout<<"The element " << ( (!tree.Exists(elementToLookFor))? "does not " : "") << "exists\n\n";
+}
+
+
+/* ----- generator functions ----- */
+
+template <typename T>
+T GenerateIntegerBT(T& bt){
+  ulong dim = getDimension();
+  Vector<int> tmp(dim);
+
+  default_random_engine gen(random_device{}());
+  uniform_int_distribution<int> dist(0,1000);
+
+  cout<<"\n\nElements in the tree (in breadth order):\n";
+  for(ulong i=0 ; i<dim ; ++i){
+    tmp[i] = dist(gen);
+    cout<<tmp[i]<<" ";
+  }
+  cout<<endl<<endl;
+
+  T tree(tmp);
+  return tree;
+}
+
+template <typename T>
+T GenerateFloatBT(T& bt){
+  ulong dim = getDimension();
+  Vector<float> tmp(dim);
+
+  default_random_engine gen(random_device{}());
+  uniform_real_distribution<double> distr(0,5);
+
+  cout<<"\n\nElements in the tree (in breadth order):\n";
+  for(unsigned long i = 0; i < dim; ++i){
+    tmp[i] = (round(distr(gen)*10000))/100;
+    cout<<tmp[i]<<" ";
+  }
+  cout<<endl<<endl;
+
+  T tree(tmp);
+  return tree;
+}
+
+template <typename T>
+T GenerateStringsBT(T& bt){
+  ulong dim = getDimension();
+  Vector<string> tmp(dim);
+
+  default_random_engine gen(random_device{}());
+  uniform_int_distribution<int> dist(1,5);
+
+  cout<<"\n\nElements in the tree (in breadth order):\n";
+  for(ulong i = 0; i < dim; ++i){
+    tmp[i] = generateRandomString(dist(gen));
+    cout<<tmp[i]<<" ";
+  }
+  cout<<endl<<endl;
+
+  T tree(tmp);
+  return tree;
+
+}
+
+string generateRandomString(ulong dim){
+  default_random_engine gen(random_device{}());
+  uniform_int_distribution<char> character('a','z');
+  char newString[dim+1];
+  for(int i=0;i<dim;i++){
+    newString[i]=character(gen);
+  }
+  newString[dim]='\0';
+  return newString;
+}
+
+ulong getDimension(){
+  ulong dimension;
+  std::cout<<"Insert the dimension: ";
+  std::cin>>dimension;
+  return dimension;
+}

librerie/exercise3/zmytest/test.hpp

@@ -2,7 +2,6 @@
 #ifndef MYTEST_HPP
 #define MYTEST_HPP
 
-
 #include"../vector/vector.hpp"
 #include"../list/list.hpp"
 #include"../queue/queue.hpp"
@@ -20,26 +19,64 @@ using namespace std;
 using namespace lasd;
 /* ************************************************************************** */
 
-void menu(){
-  cout<<"MY TESTS\n";
-  Vector<string> vec(10);
-  vec[0] = "A";
-  vec[1] = "B";
-  vec[2] = "C";
-  vec[3] = "D";
-  vec[4] = "E";
-  vec[5] = "F";
-  vec[6] = "G";
-  vec[7] = "H";
-  vec[8] = "I";
-  vec[9] = "L";
+enum class DataType{integer,ffloat,sstring};
+enum class Implementation{vector,pointers};
 
-  BinaryTreeLnk<string> bt1(vec);
-  BinaryTreeLnk<string> bt2(vec);
-  if(bt1 == bt2) cout<<"uguali";
-  else cout<<"NON UGUALI!";
-}
+void menu();
 
+template <typename T>
+void IntegerFunctions(T&);
+template <typename T>
+void FloatFunctions(T& bt);
+template <typename T>
+void StringFunctions(T&);
+
+/* ----- integer functions ----- */
+template <typename T>
+void ProductsElementsLessThan(T&);
+void AccumulateProduct(const int&, const void*, void*);
+template <typename T>
+void MultiplyByThree(T&);
+void MultiplyAnElement(int&, void*);
+
+/* ----- float functions ----- */
+template <typename T>
+void SumElementsGreaterThan(T&);
+void AccumulateSum(const float&, const void*, void*);
+
+/* ----- string functions ----- */
+template <typename T>
+void ConcatLessThan(T&);
+void ConcatAString(const string&, const void*, void*);
+
+template <typename T>
+void HeadConcat(T&);
+void HeadConcatMapAux(string&, void*);
+
+template <typename T>
+void CubeElements(T&);
+void Exponentiation(float&, void*);
+
+/* ----- shared functions ----- */
+template <template <typename...> class Tree, typename DTType>
+void PrintTree(Tree<DTType>&);
+template <typename Data>
+void PrintSingleElement(Data&, void*);
+template <template <typename...> class Tree, typename DTType>
+void CheckExistence(Tree<DTType>&);
+
+/* ----- Generator functions ----- */
+DataType ChooseDataType(); //choose data type
+Implementation ChooseImplementation();
+void UseChosenType(Implementation, DataType);
+template <typename T>
+T GenerateIntegerBT(T&);
+template <typename T>
+T GenerateFloatBT(T&);
+template <typename T>
+T GenerateStringsBT(T&);
+std::string generateRandomString(ulong);
+ulong getDimension();
 
 
 #endif