diff --git a/librerie/exercise1old/Exercise1.pdf b/librerie/exercise1/Exercise1.pdf similarity index 100% rename from librerie/exercise1old/Exercise1.pdf rename to librerie/exercise1/Exercise1.pdf diff --git a/librerie/exercise1/container/container.hpp b/librerie/exercise1/container/container.hpp index c1aeca4..c28cc43 100644 --- a/librerie/exercise1/container/container.hpp +++ b/librerie/exercise1/container/container.hpp @@ -21,7 +21,7 @@ public: virtual ~Container() = default; // Copy assignment - Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. + Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. // Move assignment Container& operator=(Container&&) noexcept = delete;; // Move assignment of abstract types should not be possible. diff --git a/librerie/exercise1/list/list.cpp b/librerie/exercise1/list/list.cpp index 14e8c61..afbe198 100644 --- a/librerie/exercise1/list/list.cpp +++ b/librerie/exercise1/list/list.cpp @@ -5,7 +5,7 @@ namespace lasd { // Specific constructors template -List::Node::Node(Data newValue){ +List::Node::Node(const Data& newValue){ value = newValue; next = nullptr; } @@ -14,20 +14,20 @@ List::Node::Node(Data newValue){ template List::Node::Node(const Node& copyFrom){ value = copyFrom.value; + next = nullptr; } - - // Move constructor template List::Node::Node(Node&& moveFrom){ - std::move(value, moveFrom.value); - std::move(next, moveFrom.next); + std::swap(value, moveFrom.value); + std::swap(next, moveFrom.next); } template List::Node::Node(Data&& moveFrom){ - std::move(value, moveFrom); + std::swap(value, moveFrom); + } @@ -37,6 +37,7 @@ bool List::Node::operator==(const Node& node)const noexcept{ return (node.value == value); } + template bool List::Node::operator!=(const Node& node)const noexcept{ return !(*this == node); @@ -88,7 +89,6 @@ template template List& List::operator=(List&& moveFrom)noexcept{ if(*this != moveFrom){ - //Clear(); std::swap(size, moveFrom.size); std::swap(head, moveFrom.head); std::swap(tail, moveFrom.tail); @@ -146,6 +146,7 @@ bool List::operator!=(const List& list) const noexcept{ else{ struct Node* tmp = head; head = head->next; + tmp->next = nullptr; delete tmp; size--; } diff --git a/librerie/exercise1/list/list.hpp b/librerie/exercise1/list/list.hpp index debbf72..926649b 100644 --- a/librerie/exercise1/list/list.hpp +++ b/librerie/exercise1/list/list.hpp @@ -31,7 +31,7 @@ protected: /* ********************************************************************** */ // Specific constructors - Node(Data); + Node(const Data&); /* ********************************************************************** */ diff --git a/librerie/exercise1/main b/librerie/exercise1/main index d4c3fa9..fc9d3de 100755 Binary files a/librerie/exercise1/main and b/librerie/exercise1/main differ diff --git a/librerie/exercise1/main.cpp b/librerie/exercise1/main.cpp index 40f1274..4fb2a3a 100644 --- a/librerie/exercise1/main.cpp +++ b/librerie/exercise1/main.cpp @@ -14,6 +14,5 @@ int main() { std::cout << "Lasd Libraries 2020" << std::endl; menu(); - //lasdtest(); // To call in the menu of your library test! return 0; } diff --git a/librerie/exercise1/zmytest/test.cpp b/librerie/exercise1/zmytest/test.cpp index f7d28f3..a649600 100644 --- a/librerie/exercise1/zmytest/test.cpp +++ b/librerie/exercise1/zmytest/test.cpp @@ -1,6 +1,7 @@ #include"test.hpp" #include #include +#include "../zlasdtest/test.hpp" void menu(){ unsigned short int choice; @@ -15,17 +16,17 @@ void menu(){ switch(choice){ case 1: - //lasd::lasdtest(); + lasdtest(); break; case 2: chosenDataStructure = ChooseDataStructure(); chosenDataType = ChooseDataType(); + UseChosenType(chosenDataStructure,chosenDataType); break; default: std::cout<<"An error has occurred"< myvec){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; @@ -131,8 +133,12 @@ void VectorIntegerFunctions(lasd::Vector myvec){ case 7: DoubleIntegers(myvec); break; + case 8: + std::cout< myvec){ unsigned short int choice; @@ -145,7 +151,8 @@ void VectorFloatFunctions(lasd::Vector myvec){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; switch(choice){ @@ -170,8 +177,12 @@ void VectorFloatFunctions(lasd::Vector myvec){ case 7: SquareFloats(myvec); break; + case 8: + std::cout< myvec){ unsigned short int choice; @@ -184,7 +195,8 @@ void VectorStringFunctions(lasd::Vector myvec){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; switch(choice){ @@ -209,8 +221,12 @@ void VectorStringFunctions(lasd::Vector myvec){ case 7: Uppercase(myvec); break; - } - }while(choice!=8); + case 8: + std::cout< void ShowFirstElement(lasd::Vector& vec){ @@ -250,9 +266,9 @@ void CheckElementExists(lasd::Vector& vec){ std::cin>>std::ws; std::cin>>element; if(vec.Exists(element)) - std::cout<<"The element exists"<& vec){ int pivot; @@ -272,7 +288,7 @@ if(data < (*(int*)par)){ void DoubleIntegers(lasd::Vector& vec){ void (*fun)(int&, void*) = DoubleAnInteger; vec.MapPreOrder(fun, nullptr); - std::cout<<"The doubled elements of the vector are: "; + std::cout<& vec){ float pivot, acc=1; void (*func)(const float&, const void*, void*) = AccumulateProduct; - std::cout<<"Which element do you choose to performa a product above it? "; + std::cout<<"Which element do you choose to perform a product above it? "; std::cin>>std::ws; std::cin>>pivot; vec.FoldPreOrder(func, (void*)&pivot, (void*)&acc); @@ -298,7 +314,7 @@ if(data > (*(float*)par)){ void SquareFloats(lasd::Vector& vec){ void (*fun)(float&, void*) = SquareAFloat; vec.MapPreOrder(fun, nullptr); - std::cout<<"The squared elements of the vector are: "; + std::cout<& vec){ void SquareAFloat(float& data, void* _){ data *= data; } - void ConcatLessThan(lasd::Vector& vec){ ulong pivot; std::string acc = ""; @@ -355,7 +370,8 @@ void ListIntegerFunctions(lasd::List mylist){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; @@ -370,19 +386,23 @@ void ListIntegerFunctions(lasd::List mylist){ ShowElementWithASpecificIndex(mylist); break; case 4: - //ShowAllElements(mylist); + ShowAllElements(mylist); break; case 5: - //CheckElementExists(mylist); + CheckElementExists(mylist); break; case 6: - //SumLessThan(mylist); + SumLessThan(mylist); break; case 7: - //DoubleIntegers(mylist); + DoubleIntegers(mylist); + break; + case 8: + std::cout< mylist){ unsigned short int choice; @@ -395,7 +415,8 @@ void ListFloatFunctions(lasd::List mylist){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; switch(choice){ @@ -409,19 +430,23 @@ void ListFloatFunctions(lasd::List mylist){ ShowElementWithASpecificIndex(mylist); break; case 4: - //ShowAllElements(myvec); + ShowAllElements(mylist); break; case 5: - //CheckElementExists(myvec); + CheckElementExists(mylist); break; case 6: - //ProductMoreThan(myvec); + ProductMoreThan(mylist); break; case 7: - //SquareFloats(myvec); + SquareFloats(mylist); break; - } - }while(choice!=8); + case 8: + std::cout< mylist){ unsigned short int choice; @@ -434,7 +459,8 @@ void ListStringFunctions(lasd::List mylist){ std::cout<<"5. Controlla esistenza di uno specifico valore"<>std::ws; std::cin>>choice; switch(choice){ @@ -448,19 +474,23 @@ void ListStringFunctions(lasd::List mylist){ ShowElementWithASpecificIndex(mylist); break; case 4: - //ShowAllElements(myvec); + ShowAllElements(mylist); break; case 5: - // CheckElementExists(myvec); + CheckElementExists(mylist); break; case 6: - //ConcatLessThan(myvec); + ConcatLessThan(mylist); break; case 7: - //Uppercase(myvec); + Uppercase(mylist); break; - } - }while(choice!=8); + case 8: + std::cout< @@ -483,6 +513,85 @@ void ShowElementWithASpecificIndex(lasd::List& list){ std::cout< +void ShowAllElements(lasd::List& list){ + void (*AuxMapPreOrder) (Data&, void*) = PrintSingleElement; + std::cout<<"The list contains:"< +void CheckElementExists(lasd::List& list){ + Data element; + std::cout<<"What element do you wanna check its exsistence on? "; + std::cin>>std::ws; + std::cin>>element; + if(list.Exists(element)) + std::cout<<"The element exists"<& list){ + int pivot; + ulong acc=0; + void (*func)(const int&, const void*, void*) = AccumulateSum; + std::cout<<"Which element do you choose to performa a sum under it? "; + std::cin>>std::ws; + std::cin>>pivot; + list.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The result of the sum is "<& list){ + void (*fun)(int&, void*) = DoubleAnInteger; + list.MapPreOrder(fun, nullptr); + std::cout<& list){ + float pivot, acc=1; + void (*func)(const float&, const void*, void*) = AccumulateProduct; + std::cout<<"Which element do you choose to perform a product above it? "; + std::cin>>std::ws; + std::cin>>pivot; + list.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The result of the product is "<& list){ + void (*fun)(float&, void*) = SquareAFloat; + list.MapPreOrder(fun, nullptr); + std::cout<& list){ + ulong pivot; + std::string acc = ""; + void (*func)(const std::string&, const void*, void*) = ConcatAux; + std::cout<<"Concat elements whose length is less than: "; + std::cin>>std::ws; + std::cin>>pivot; + list.FoldPreOrder(func, (void*)&pivot, (void*)&acc); + std::cout<<"The concatenated string is "<& list){ + void (*fun)(std::string&, void*) = UppercaseAString; + list.MapPreOrder(fun, nullptr); + std::cout<<"The uppercased strings are: "< generateVectorOfIntegers(){ for(ulong i = 0 ; i generateVectorOfFloat(){ for(unsigned long i = 0; i < dim; ++i){ myvec[i] = (round(distr(gen)*10000))/100; } - std::cout<<"Elements of the vector:"< generateVectorOfStrings(){ for(unsigned long i = 0; i < dim; ++i){ myvec[i] = generateRandomString(dist(gen)); } - std::cout<<"Elements of the vector:"< void ShowLastElement(lasd::List&); template void ShowElementWithASpecificIndex(lasd::List&); +template +void ShowAllElements(lasd::List&); +template +void CheckElementExists(lasd::List&); +void SumLessThan(lasd::List&); +void DoubleIntegers(lasd::List&); +void ProductMoreThan(lasd::List&); +void SquareFloats(lasd::List&); +void ConcatLessThan(lasd::List&); +void Uppercase(lasd::List&); ulong getDimension(); -/* -void ChooseDimension(ulong&); -LinearContainer GenerateRandomStructure(const ulong&); -void ViewElement(const LinearContainer&); -void PrintAllElements(const LinearContainer&); -void PrintElement(Data&, void*); // funzione richiamata dalla map -void CheckExists(const LinearContainer&); -void ChooseFoldFunction(const LinearContainer&); -void SumLessThan(const LinearContainer&, const ulong&); -void SumLessThanFold(int&, const void*, void*); -void ProductMoreThan(const LinearContainer&, const ulong&); -void ProductMoreThanFold(float&, const void*, void*); -void ConcatStringLessThan(const LinearContainer&, const ulong&); -void ConcatStringLessThanFold(string&, const void*, void*); - -//7 -void ChooseMapFunction(const LinearContainer); -void DoubleN(const LinearContainer&, const ulong&); -void DoubleNMap(int&, void*); - -void SquareN(const LinearContainer&, const ulong&); -void SquareNMap(float&, void*); - -void Uppercase(const LinearContainer&, const ulong&); -void UppercaseMap(string&, void*); -*/ - #endif diff --git a/librerie/exercise1old/build.sh b/librerie/exercise1old/build.sh deleted file mode 100755 index bbee40e..0000000 --- a/librerie/exercise1old/build.sh +++ /dev/null @@ -1,7 +0,0 @@ - -#! /bin/bash - -g++ -O3 -o main \ - zlasdtest/exercise1/simpletest.cpp zlasdtest/exercise1/fulltest.cpp \ - zlasdtest/container/container.cpp \ - zlasdtest/test.cpp zmytest/test.cpp main.cpp diff --git a/librerie/exercise1old/container/container.cpp b/librerie/exercise1old/container/container.cpp deleted file mode 100644 index 6a22d84..0000000 --- a/librerie/exercise1old/container/container.cpp +++ /dev/null @@ -1,17 +0,0 @@ - -namespace lasd { - -template -void AuxFoldExists(const Data& dat, const void* val, void* exists){ - if(dat == *((Data*)val)){ - *((bool*)exists) = true; - } -} - -template -bool FoldableContainer::Exists(const Data& dat) const noexcept{ - bool exists = false; - FoldPreOrder(&AuxFoldExists, &dat, &exists); - return exists; -} -} diff --git a/librerie/exercise1old/container/container.hpp b/librerie/exercise1old/container/container.hpp deleted file mode 100644 index 021fcc0..0000000 --- a/librerie/exercise1old/container/container.hpp +++ /dev/null @@ -1,304 +0,0 @@ - -#ifndef CONTAINER_HPP -#define CONTAINER_HPP - -/* ************************************************************************** */ - -#include -#include - -/* ************************************************************************** */ - -namespace lasd { - -/* ************************************************************************** */ - -class Container { - -private: - -protected: - - ulong size = 0; - -public: - - // Destructor - virtual ~Container() = default; - - /* ************************************************************************ */ - - // Copy assignment - Container& operator=(const Container&) = delete; // Copy assignment of abstract types should not be possible. - - // Move assignment - Container& operator=(Container&&) noexcept = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const Container&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - virtual bool Empty() const noexcept { // (concrete function should not throw exceptions) - return (size == 0); - } - - virtual ulong Size() const noexcept{ - return size; - } - - virtual void Clear() = 0; - -}; - -/* ************************************************************************** */ - -template -class LinearContainer : virtual public Container { // Must extend Container - -private: - -protected: - -public: - - // Destructor - virtual ~LinearContainer() = default; - - /* ************************************************************************ */ - - // Copy assignment - LinearContainer& operator=(const LinearContainer&) = delete; // Copy assignment of abstract types should not be possible. - - // Move assignment - LinearContainer& operator=(LinearContainer&&) = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const LinearContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - virtual Data& Front() const = 0; // (concrete function must throw std::length_error when empty) - virtual Data& Back() const = 0; // (concrete function must throw std::length_error when empty) - - virtual Data& operator[](const ulong) const = 0; // (concrete function must throw std::out_of_range when out of range) - -}; - -/* ************************************************************************** */ - -template -class TestableContainer : virtual public Container { // Must extend Container - -private: - -protected: - -public: - - // Destructor - virtual ~TestableContainer() = default; - - /* ************************************************************************ */ - - // Copy assignment - TestableContainer& operator=(const TestableContainer&) = delete; // Copy assignment of abstract types should not be possible. - - // Move assignment - TestableContainer& operator=(TestableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const TestableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - virtual bool Exists(const Data&) const noexcept = 0; // (concrete function should not throw exceptions) - -}; - -/* ************************************************************************** */ - -template -class MappableContainer : virtual public Container { // Must extend Container - -private: - -protected: - -public: - - // Destructor - virtual ~MappableContainer() = default; - - /* ************************************************************************ */ - - // Copy assignment - MappableContainer& operator=(const MappableContainer&) = delete; // Copy assignment of abstract types should not be possible. - - // Move assignment - MappableContainer& operator=(MappableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const MappableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - typedef std::function MapFunctor; - - virtual void MapPreOrder(const MapFunctor, void*) = 0; - virtual void MapPostOrder(const MapFunctor, void*) = 0; - -}; - -/* ************************************************************************** */ - -template -class FoldableContainer : virtual public TestableContainer{ // Must extend TestableContainer - -private: - -protected: - -public: - - // Destructor - virtual ~FoldableContainer() = default; - - /* ************************************************************************ */ - - // Copy assignment - FoldableContainer& operator=(const FoldableContainer&) = delete; // Copy assignment of abstract types should not be possible. - - // Move assignment - FoldableContainer& operator=(FoldableContainer&&) noexcept = delete; // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - bool operator!=(const FoldableContainer&) const noexcept = delete; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - typedef std::function FoldFunctor; - - virtual void FoldPreOrder(const FoldFunctor, const void*, void*) const = 0; - virtual void FoldPostOrder(const FoldFunctor, const void*, void*) const = 0; - - virtual bool Exists(const Data&) const noexcept override; // Override TestableContainer member - -}; - -/* ************************************************************************** */ - -template -class BreadthMappableContainer { // Must extend MappableContainer - -private: - - // ... - -protected: - - // ... - -public: - - // Destructor - // ~BreadthMappableContainer() specifiers - - /* ************************************************************************ */ - - // Copy assignment - // type operator=(argument); // Copy assignment of abstract types should not be possible. - - // Move assignment - // type operator=(argument); // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - // type operator==(argument) specifiers; // Comparison of abstract types might not be possible. - // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - // using typename MappableContainer::MapFunctor; - - // type MapBreadth(arguments) specifiers; - -}; - -/* ************************************************************************** */ - -template -class BreadthFoldableContainer { // Must extend FoldableContainer - -private: - - // ... - -protected: - - // ... - -public: - - // Destructor - // ~BreadthFoldableContainer() specifiers - - /* ************************************************************************ */ - - // Copy assignment - // type operator=(argument); // Copy assignment of abstract types should not be possible. - - // Move assignment - // type operator=(argument); // Move assignment of abstract types should not be possible. - - /* ************************************************************************ */ - - // Comparison operators - // type operator==(argument) specifiers; // Comparison of abstract types might not be possible. - // type operator!=(argument) specifiers; // Comparison of abstract types might not be possible. - - /* ************************************************************************ */ - - // Specific member functions - - // using typename FoldableContainer::FoldFunctor; - - // type FoldBreadth(arguments) specifiers; - -}; - -/* ************************************************************************** */ - -} - -#include "container.cpp" - -#endif diff --git a/librerie/exercise1old/list/list.cpp b/librerie/exercise1old/list/list.cpp deleted file mode 100644 index ce55016..0000000 --- a/librerie/exercise1old/list/list.cpp +++ /dev/null @@ -1,264 +0,0 @@ -namespace lasd { - // Specific constructor - template - List::Node::Node(Data newValue){ - value = newValue; - next = nullptr; - } - - // Copy constructor - template - List::Node::Node(const Node& copyFrom){ - value = copyFrom.value; - } - - // Move constructor - template - List::Node::Node(Node&& moveFrom){ - std::move(value, moveFrom.value); - std::move(next, moveFrom.next); - } - template - List::Node::Node(Data&& moveFrom){ - std::move(value, moveFrom); - } - - // Comparison operator - template - bool List::Node::operator==(const Node& node) const noexcept{ - if(node.value == value) return true; - else return false; - } - - template - bool List::Node::operator!=(const Node& node) const noexcept{ - if(node.value != value) return true; - else return false; - } - - template - List::List(const LinearContainer& con){ - for(ulong i=0 ; i - List::List(const List& copyFrom){ - for(ulong i=0 ; i - List::List(List&& moveFrom){ - std::swap(size, moveFrom.size); - std::swap(head, moveFrom.head); - std::swap(tail, moveFrom.tail); - } - - // Destructor - template - List::~List(){ - Clear(); - } - - // Copy assignment - template - List& List::operator=(const List& copyFrom){ - if(*this != copyFrom){ - Clear(); - for(ulong i=0 ; i - List& List::operator=(List&& moveFrom) noexcept{ - if(*this != moveFrom){ - Clear(); - std::swap(size, moveFrom.size); - std::swap(head, moveFrom.head); - std::swap(tail, moveFrom.tail); - } - return *this; - } - - // Comparison operators - template - bool List::operator==(const List& list) const noexcept{ - if(this->size != list.Size()) return false; - for(ulong i=0 ; i<(this->size) ; ++i){ - if((*this)[i] != list[i]) return false; - } - return true; - } - - template - bool List::operator!=(const List& list) const noexcept{ - return !(*this == list); - } - - // Specific member functions - template - void List::InsertAtFront(const Data& data){ - struct Node* tmp = new Node(data); - tmp->next = head; - head = tmp; - size++; - if(size==1){ - tail = head; - } - } - - template - void List::InsertAtFront(Data&& data){ - struct Node* tmp = new Node(data); - tmp->next = head; - head = tmp; - size++; - if(size==1){ - tail = head; - } - } - - template - void List::RemoveFromFront(){ - if(head==nullptr){ - throw std::length_error("List is empty!"); - }else{ - struct Node* tmp = head; - head = head->next; - delete tmp; - size--; - } - } - - template - Data List::FrontNRemove(){ - if(head==nullptr){ - throw std::length_error("List is empty!"); - }else{ - Data value = head->value; - RemoveFromFront(); - return value; - } - } - - template - void List::InsertAtBack(const Data& data){ - if(size==0){ - InsertAtFront(data); - }else{ - struct Node* last = new Node(data); - tail->next = last; - tail = last; - size++; - } - } - - template - void List::InsertAtBack(Data&& data){ - if(size==0){ - InsertAtFront(data); - }else{ - struct Node* last = new Node(data); - tail->next = last; - tail = last; - size++; - } - } - - template - void List::Clear(){ - while(head!=nullptr){ - RemoveFromFront(); - } - } - - template - Data& List::Front() const{ - if(size==0){ - throw std::length_error("List is empty!"); - }else{ - return head->value; - } - } - - template - Data& List::Back() const{ - if(size==0){ - throw std::length_error("List is empty!"); - }else{ - return tail->value; - } - } - - template - Data& List::operator[](const ulong index) const{ - if(index>=size || index<0){ - throw std::out_of_range("Out of range!"); - }else{ - struct Node* tmp = head; - for(ulong i=0 ; inext; - } - return tmp->value; - } - } - - template - void List::MapPreOrder(const MapFunctor fun, void* par){ - MapPreOrder(fun, par, head); - } - - template - void List::MapPreOrder(MapFunctor function, void* par, struct Node* node){ - if(node == nullptr) - return; - function(node->value, par); - MapPreOrder(function, par, node->next); - } - - template - void List::MapPostOrder(MapFunctor function, void* par){ - MapPostOrder(function, par, head); - } - - template - void List::MapPostOrder(MapFunctor function, void* par, struct Node* node){ - if(node == nullptr) - return; - MapPostOrder(function, par, node->next); - function(node->value, par); - } - - template - void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par) const{ - FoldPreOrder(function, constPar, par, head); - } - - template - void List::FoldPreOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ - if(node == nullptr) - return; - function(node->value, constPar, par); - FoldPreOrder(function, constPar, par, node->next); - } - - template - void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par) const{ - FoldPostOrder(function, constPar, par, head); -} - - template - void List::FoldPostOrder(FoldFunctor function, const void* constPar, void* par, struct Node* node) const{ - if(node == nullptr) - return; - FoldPostOrder(function, constPar, par, node->next); - function(node->value, constPar, par); - } -} diff --git a/librerie/exercise1old/list/list.hpp b/librerie/exercise1old/list/list.hpp deleted file mode 100644 index 99bf595..0000000 --- a/librerie/exercise1old/list/list.hpp +++ /dev/null @@ -1,164 +0,0 @@ - -#ifndef LIST_HPP -#define LIST_HPP - -/* ************************************************************************** */ - -#include "../container/container.hpp" - -/* ************************************************************************** */ - -namespace lasd { - -/* ************************************************************************** */ - -template -class List : virtual public LinearContainer, - virtual public MappableContainer, - virtual public FoldableContainer { // Must extend LinearContainer, MappableContainer, and FoldableContainer - -private: - -protected: - - using LinearContainer:: size; - - struct Node - { - Data value; - Node* next = nullptr; - - /* ********************************************************************** */ - - // Specific constructors - Node(Data); - - /* ********************************************************************** */ - - // Copy constructor - Node(const Node&); - - // Move constructor - Node(Node&&); - Node(Data&&); - - /* ********************************************************************** */ - - // Destructor - ~Node() = default; - - /* ********************************************************************** */ - - // Comparison operators - bool operator==(const Node&) const noexcept; - bool operator!=(const Node&) const noexcept; - }; - - struct Node* head = nullptr; - struct Node* tail = nullptr; - -public: - - // Default constructor - List() = default; - - /* ************************************************************************ */ - - // Specific constructor - List(const LinearContainer&); // A list obtained from a LinearContainer - - /* ************************************************************************ */ - - // Copy constructor - List(const List&); - - //Move constructor - List(List&&); - - /* ************************************************************************ */ - - // Destructor - ~List(); - - /* ************************************************************************ */ - - // Copy assignment - List& operator=(const List&); - - // Move assignment - List& operator=(List&&) noexcept; - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const List&) const noexcept; - bool operator!=(const List&) const noexcept; - - /* ************************************************************************ */ - - // Specific member functions - - void InsertAtFront(const Data&); // Copy of the value - void InsertAtFront(Data&&); // Move of the value - void RemoveFromFront(); // (must throw std::length_error when empty) - Data FrontNRemove(); // (must throw std::length_error when empty) - - void InsertAtBack(const Data&); // Copy of the value - void InsertAtBack(Data&&); // Move of the value - - /* ************************************************************************ */ - - // Specific member functions (inherited from Container) - - void Clear() override; // Override Container member - - /* ************************************************************************ */ - - // Specific member functions (inherited from LinearContainer) - - Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty) - Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty) - - Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range) - - /* ************************************************************************ */ - - // Specific member functions (inherited from MappableContainer) - - using typename MappableContainer::MapFunctor; - - void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member - void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member - - /* ************************************************************************ */ - - // Specific member functions (inherited from FoldableContainer) - - using typename FoldableContainer::FoldFunctor; - - void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member - void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member - -protected: - - // Auxiliary member functions (for MappableContainer) - - void MapPreOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards - void MapPostOrder(const MapFunctor, void*, struct Node*); // Accessory function executing from one point of the list onwards - - /* ************************************************************************ */ - - // Auxiliary member functions (for FoldableContainer) - - void FoldPreOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards - void FoldPostOrder(const FoldFunctor, const void*, void*, struct Node*) const; // Accessory function executing from one point of the list onwards - -}; - -/* ************************************************************************** */ - -} - -#include "list.cpp" - -#endif diff --git a/librerie/exercise1old/main.cpp b/librerie/exercise1old/main.cpp deleted file mode 100644 index 9c587bb..0000000 --- a/librerie/exercise1old/main.cpp +++ /dev/null @@ -1,18 +0,0 @@ -#include "container/container.hpp" -#include "vector/vector.hpp" -#include "list/list.hpp" -#include "zlasdtest/test.hpp" - -#include "zmytest/test.hpp" - -/* ************************************************************************** */ - -#include - -/* ************************************************************************** */ - -int main() { - std::cout << "Lasd Libraries 2020" << std::endl; - lasdtest(); // To call in the menu of your library test! - return 0; -} diff --git a/librerie/exercise1old/vector/vector.cpp b/librerie/exercise1old/vector/vector.cpp deleted file mode 100644 index 7b7d8ef..0000000 --- a/librerie/exercise1old/vector/vector.cpp +++ /dev/null @@ -1,181 +0,0 @@ -namespace lasd { - - // Specific constructor - template - Vector::Vector(const ulong dimension){ - Elements = new Data[dimension] {}; - size = dimension; - } - - // Specific constructor - template - Vector::Vector(const LinearContainer& con){ - size = con.Size(); - Elements = new Data[size] {}; - for(ulong i ; i - Vector::Vector(const Vector& vec){ - size = vec.size; - Elements = new Data[size] {}; - for(ulong i=0 ; i - Vector::Vector(Vector&& vec) noexcept{ - std::swap(Elements, vec.Elements); - std::swap(size, vec.size); - } - - // Destructor - template - Vector::~Vector(){ - delete[] Elements; - } - - // Copy assignment - template - Vector& Vector::operator=(const Vector& vec){ - Vector* tmpvec = new Vector(vec); - std::swap(*tmpvec,*this); - delete tmpvec; - return *this; - } - - // Move assignment - template - Vector& Vector::operator=(Vector&& vec) noexcept{ - std::swap(Elements, vec.Elements); - std::swap(size, vec.size); - return *this; - } - - // Comparison operators - template - bool Vector::operator==(const Vector& vec) const noexcept{ - if(size!=vec.size) return false; - for(ulong i=0 ; i - bool Vector::operator!=(const Vector& vec) const noexcept{ - return !(*this == vec); - } - - // Specific member function - // template typename - // void Vector::Resize(const ulong newsize){ - // if(newsize == 0){ - // Clear(); - // } - // else{ - // size = newsize; - // if(newsize < size){ - // Data* tmpvec = new Data[newsize] {}; - // for(ulong i=0;i size){ - // Data* tmpvec = new Data[newsize] {}; - // for(ulong i=0;i - void Vector::Resize(const ulong newsize){ - if(newsize == 0){ - Clear(); - }else if(size != newsize){ - ulong limit = (size < newsize) ? size : newsize; - Data* TmpElements = new Data[newsize] {}; - for(ulong i = 0 ; i - void Vector::Clear(){ - delete[] Elements; - Elements = nullptr; - size = 0; - } - - template - Data& Vector::Front() const{ - if(size!=0){ - return Elements[0]; - }else{ - return std::length_error("Access to an empty vector"); - } - } - - template - Data& Vector::Back() const{ - if(size!=0){ - return Elements[size-1]; - }else{ - return std::length_error("Access to an empty vector"); - } - } - - template - Data& Vector::operator[](const ulong index) const{ - if(index < size){ - return Elements[index]; - }else{ - throw std::out_of_range("Access at index " + std::to_string(index) + " invalid because the vector size is" + std::to_string(size)); - } - } - - template - void Vector::MapPreOrder(const MapFunctor fun, void* par){ - for(ulong i = 0 ; i - void Vector::MapPostOrder(const MapFunctor fun, void* par){ - ulong i = size; - while(i>0){ - fun(Elements[--i], par); - } - } - - template - void Vector::FoldPreOrder(const FoldFunctor fun, const void* par, void* acc) const{ - for(ulong i = 0 ; i - void Vector::FoldPostOrder(const FoldFunctor fun, const void* par, void* acc) const{ - ulong i = size; - while(i>0){ - fun(Elements[--i], par, acc); - } - } diff --git a/librerie/exercise1old/vector/vector.hpp b/librerie/exercise1old/vector/vector.hpp deleted file mode 100644 index 3c25b30..0000000 --- a/librerie/exercise1old/vector/vector.hpp +++ /dev/null @@ -1,105 +0,0 @@ - -#ifndef VECTOR_HPP -#define VECTOR_HPP - -#include "../container/container.hpp" - -namespace lasd { - -template -class Vector : virtual public LinearContainer, - virtual public MappableContainer, - virtual public FoldableContainer{ // Must extend LinearContainer, MappableContainer, and FoldableContainer - -private: - -protected: - - using LinearContainer::size; - Data* Elements = nullptr; -public: - - // Default constructor - Vector() = default; - - /* ************************************************************************ */ - - // Specific constructors - Vector(const ulong); // A vector with a given initial dimension - Vector(const LinearContainer&); // A vector obtained from a LinearContainer - - /* ************************************************************************ */ - - // Copy constructor - Vector(const Vector&); - - // Move constructor - Vector(Vector&&) noexcept; - - /* ************************************************************************ */ - - // Destructor - ~Vector(); - - /* ************************************************************************ */ - - // Copy assignment - Vector& operator=(const Vector&); - - // Move assignment - Vector& operator=(Vector&&) noexcept; - - /* ************************************************************************ */ - - // Comparison operators - bool operator==(const Vector&) const noexcept; - bool operator!=(const Vector&) const noexcept; - - /* ************************************************************************ */ - - // Specific member functions - - void Resize(const ulong); // Resize the vector to a given size - - /* ************************************************************************ */ - - // Specific member functions (inherited from Container) - - void Clear() override; // Override Container member - - /* ************************************************************************ */ - - // Specific member functions (inherited from LinearContainer) - - Data& Front() const override; // Override LinearContainer member (must throw std::length_error when empty) - Data& Back() const override; // Override LinearContainer member (must throw std::length_error when empty) - - Data& operator[](const ulong) const override; // Override LinearContainer member (must throw std::out_of_range when out of range) - - /* ************************************************************************ */ - - // Specific member functions (inherited from MappableContainer) - - using typename MappableContainer::MapFunctor; - - void MapPreOrder(const MapFunctor, void*) override; // Override MappableContainer member - void MapPostOrder(const MapFunctor, void*) override; // Override MappableContainer member - - /* ************************************************************************ */ - - // Specific member functions (inherited from FoldableContainer) - - using typename FoldableContainer::FoldFunctor; - - void FoldPreOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member - void FoldPostOrder(const FoldFunctor, const void*, void*) const override; // Override FoldableContainer member - -}; - -/* ************************************************************************** */ - -} - -#include "vector.cpp" - -#endif diff --git a/librerie/exercise1old/zlasdtest/container/container.cpp b/librerie/exercise1old/zlasdtest/container/container.cpp deleted file mode 100644 index 0f37c81..0000000 --- a/librerie/exercise1old/zlasdtest/container/container.cpp +++ /dev/null @@ -1,49 +0,0 @@ - -#include - -/* ************************************************************************** */ - -#include "../../container/container.hpp" - -/* ************************************************************************** */ - -// Container member functions! - -void Empty(uint& testnum, uint& testerr, const lasd::Container& con, bool chk) { - bool tst; - testnum++; - std::cout << " " << testnum << " The container is " << ((tst = con.Empty()) ? "" : "not ") << "empty: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - testerr += (1 - (uint) tst); -} - -void Size(uint& testnum, uint& testerr, const lasd::Container& con, bool chk, ulong siz) { - bool tst; - testnum++; - std::cout << " " << testnum << " The container has size " << con.Size() << ": "; - std::cout << ((tst = ((con.Size() == siz) == chk)) ? "Correct" : "Error") << "!" << std::endl; - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -// Auxiliary functions for MappableContainer! - -void MapStringAppend(std::string& dat, void* par) { - dat.append(*((std::string*) par)); -} - -/* ************************************************************************** */ - -// Auxiliary functions for FoldableContainer! - -void FoldParity(const int& dat, const void* _, void* acc) { - *((int*) acc) += dat; - *((int*) acc) %= 2; -} - -void FoldStringConcatenate(const std::string& dat, const void* _, void* acc) { - ((std::string*) acc)->append(dat); -} - -/* ************************************************************************** */ diff --git a/librerie/exercise1old/zlasdtest/container/container.hpp b/librerie/exercise1old/zlasdtest/container/container.hpp deleted file mode 100644 index 7b12b44..0000000 --- a/librerie/exercise1old/zlasdtest/container/container.hpp +++ /dev/null @@ -1,301 +0,0 @@ - -#ifndef CONTAINERTEST_HPP -#define CONTAINERTEST_HPP - -#include "../../container/container.hpp" - -/* ************************************************************************** */ - -// Container member functions! - -void Empty(uint&, uint&, const lasd::Container&, bool); - -void Size(uint&, uint&, const lasd::Container&, bool, ulong); - -/* ************************************************************************** */ - -// LinearContainer member functions! - -template -void GetFront(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The front of the linear container is \"" << con.Front() << "\": "; - std::cout << ((tst = ((con.Front() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void SetFront(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Setting the front of the linear container to \"" << val << "\": "; - con.Front() = val; - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void GetBack(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The back of the linear container is \"" << con.Back() << "\": "; - std::cout << ((tst = ((con.Back() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void SetBack(uint& testnum, uint& testerr, const lasd::LinearContainer& con, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Setting the back of the linear container to \"" << val << "\": "; - con.Back() = val; - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void SetAt(uint& testnum, uint& testerr, lasd::LinearContainer& con, bool chk, const ulong& ind, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Set of the linear container at index \"" << ind << "\" with value \"" << val << "\": "; - con[ind] = val; - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::out_of_range exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void GetAt(uint& testnum, uint& testerr, lasd::LinearContainer& con, bool chk, const ulong& ind, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Get of the linear container at index \"" << ind << "\" with value \"" << con[ind] << "\": "; - std::cout << ((tst = ((con[ind] == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::out_of_range exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - tst = true; - std::cout << std::endl << "Wrong std::exception: " << exc.what() << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -// TestableContainer member functions! - -template -void Exists(uint& testnum, uint& testerr, const lasd::TestableContainer& con, bool chk, const Data& val) { - bool tst; - testnum++; - std::cout << " " << testnum << " Data \"" << val << "\" " << ((tst = con.Exists(val)) ? "does" : "does not") << " exist: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -// MappableContainer member functions! - -template -void MapPreOrder(uint& testnum, uint& testerr, lasd::MappableContainer& con, bool chk, typename lasd::MappableContainer::MapFunctor fun, const Parameter& inipar) { - bool tst = true; - testnum++; - Parameter par = {inipar}; - try { - std::cout << " " << testnum << " Executing map in pre order - "; - con.MapPreOrder(fun, &par); - std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void MapPostOrder(uint& testnum, uint& testerr, lasd::MappableContainer& con, bool chk, typename lasd::MappableContainer::MapFunctor fun, const Parameter& inipar) { - bool tst = true; - testnum++; - Parameter par = {inipar}; - try { - std::cout << " " << testnum << " Executing map in post order - "; - con.MapPostOrder(fun, &par); - std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void MapPrint(const Data& dat, void* _) { - std::cout << dat << " "; -} - -template -void MapIncrement(Data& dat, void* _) { - dat++; -} - -template -void MapIncrementNPrint(Data& dat, void* _) { - std::cout << dat++ << "->" << dat << "; "; -} - -template -void MapDouble(Data& dat, void* _) { - dat *= 2; -} - -template -void MapDoubleNPrint(Data& dat, void* _) { - std::cout << dat << "->" << (dat *= 2) << "; "; -} - -template -void MapInvert(Data& dat, void* _) { - dat = -dat; -} - -template -void MapInvertNPrint(Data& dat, void* _) { - std::cout << dat << "->" << (dat = -dat) << "; "; -} - -template -void MapParityInvert(Data& dat, void* _) { - if (dat % 2 != 0) { dat = -dat; } -} - -void MapStringAppend(std::string&, void*); - -/* ************************************************************************** */ - -// FoldableContainer member functions! - -template -void FoldPreOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer& con, bool chk, typename lasd::FoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { - bool tst; - testnum++; - Parameter par = {inipar}; - Value val = inival; - try { - std::cout << " " << testnum << " Executing fold in pre order - "; - con.FoldPreOrder(fun, &par, &val); - std::cout << "obtained value is \"" << val << "\": "; - std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void FoldPostOrder(uint& testnum, uint& testerr, const lasd::FoldableContainer& con, bool chk, typename lasd::FoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { - bool tst; - testnum++; - Parameter par = {inipar}; - Value val = inival; - try { - std::cout << " " << testnum << " Executing fold in post order - "; - con.FoldPostOrder(fun, &par, &val); - std::cout << "obtained value is \"" << val << "\": "; - std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void FoldAdd(const Data& dat, const void* _, void* acc) { - *((Data*) acc) += dat; -} - -template -void FoldMultiply(const Data& dat, const void* _, void* acc) { - *((Data*) acc) *= dat; -} - -void FoldParity(const int&, const void*, void*); - -void FoldStringConcatenate(const std::string&, const void*, void*); - -/* ************************************************************************** */ - -// BreadthMappableContainer member functions! - -template -void MapBreadth(uint& testnum, uint& testerr, lasd::BreadthMappableContainer& con, bool chk, typename lasd::BreadthMappableContainer::MapFunctor fun, const Parameter& inipar) { - bool tst = true; - testnum++; - Parameter par = {inipar}; - try { - std::cout << " " << testnum << " Executing map in pre order - "; - con.MapBreadth(fun, &par); - std::cout << ": " << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -// BreadthFoldableContainer member functions! - -template -void FoldBreadth(uint& testnum, uint& testerr, const lasd::BreadthFoldableContainer& con, bool chk, typename lasd::BreadthFoldableContainer::FoldFunctor fun, const Parameter& inipar, const Value& inival, const Value& finval) { - bool tst; - testnum++; - Parameter par = {inipar}; - Value val = inival; - try { - std::cout << " " << testnum << " Executing fold in post order - "; - con.FoldBreadth(fun, &par, &val); - std::cout << "obtained value is \"" << val << "\": "; - std::cout << ((tst = ((val == finval) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -#endif diff --git a/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp b/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp deleted file mode 100644 index 27f84be..0000000 --- a/librerie/exercise1old/zlasdtest/exercise1/fulltest.cpp +++ /dev/null @@ -1,3 +0,0 @@ - -void testFullExercise1() { -} diff --git a/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp b/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp deleted file mode 100644 index 8fbc655..0000000 --- a/librerie/exercise1old/zlasdtest/exercise1/simpletest.cpp +++ /dev/null @@ -1,447 +0,0 @@ - -#include - -/* ************************************************************************** */ - -#include "../container/container.hpp" - -#include "../vector/vector.hpp" - -#include "../list/list.hpp" - -/* ************************************************************************** */ - -using namespace std; - -/* ************************************************************************** */ - -void stestVectorInt(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector Test:" << endl; - try { - { - lasd::Vector vec; - Empty(loctestnum, loctesterr, vec, true); - - GetFront(loctestnum, loctesterr, vec, false, 0); - GetBack(loctestnum, loctesterr, vec, false, 0); - SetAt(loctestnum, loctesterr, vec, false, 1, 0); - GetAt(loctestnum, loctesterr, vec, false, 2, 0); - - Exists(loctestnum, loctesterr, vec, false, 0); - - MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); - MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); - - FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 0); - FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 0); - } - { - lasd::Vector vec(3); - Empty(loctestnum, loctesterr, vec, false); - Size(loctestnum, loctesterr, vec, true, 3); - - SetAt(loctestnum, loctesterr, vec, true, 0, 4); - SetAt(loctestnum, loctesterr, vec, true, 1, 3); - SetAt(loctestnum, loctesterr, vec, true, 2, 1); - - GetFront(loctestnum, loctesterr, vec, true, 4); - GetBack(loctestnum, loctesterr, vec, true, 1); - - SetFront(loctestnum, loctesterr, vec, true, 5); - SetBack(loctestnum, loctesterr, vec, true, 4); - - Exists(loctestnum, loctesterr, vec, true, 4); - - MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); - MapPostOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0, 0, 12); - FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0, 1, 60); - - vec.Resize(2); - FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0, 1, 15); - } - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVectorDouble(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector Test:" << endl; - try { - lasd::Vector vec(3); - Empty(loctestnum, loctesterr, vec, false); - Size(loctestnum, loctesterr, vec, true, 3); - - SetAt(loctestnum, loctesterr, vec, true, 0, 5.5); - SetAt(loctestnum, loctesterr, vec, true, 1, 3.3); - SetAt(loctestnum, loctesterr, vec, true, 2, 1.1); - - GetFront(loctestnum, loctesterr, vec, true, 5.5); - GetBack(loctestnum, loctesterr, vec, true, 1.1); - - Exists(loctestnum, loctesterr, vec, true, 3.3); - - FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldAdd, 0.0, 0.0, 9.9); - FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldMultiply, 0.0, 1.0, 19.965); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVectorString(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector Test:" << endl; - try { - lasd::Vector vec(2); - Empty(loctestnum, loctesterr, vec, false); - Size(loctestnum, loctesterr, vec, true, 2); - - SetAt(loctestnum, loctesterr, vec, true, 0, string("A")); - SetAt(loctestnum, loctesterr, vec, true, 1, string("B")); - - GetFront(loctestnum, loctesterr, vec, true, string("A")); - GetBack(loctestnum, loctesterr, vec, true, string("B")); - - Exists(loctestnum, loctesterr, vec, true, string("A")); - - MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string(" ")); - MapPreOrder(loctestnum, loctesterr, vec, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XA B ")); - FoldPostOrder(loctestnum, loctesterr, vec, true, &FoldStringConcatenate, string(""), string("X"), string("XB A ")); - - Exists(loctestnum, loctesterr, vec, false, string("A")); - - lasd::Vector copvec(vec); - EqualVector(loctestnum, loctesterr, vec, copvec, true); - MapPreOrder(loctestnum, loctesterr, vec, true, &MapStringAppend, string("!")); - NonEqualVector(loctestnum, loctesterr, vec, copvec, true); - - copvec = std::move(vec); - FoldPreOrder(loctestnum, loctesterr, copvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A !B !")); - - lasd::Vector movvec(std::move(vec)); - FoldPreOrder(loctestnum, loctesterr, movvec, true, &FoldStringConcatenate, string(""), string("?"), string("?A B ")); - SetAt(loctestnum, loctesterr, vec, false, 1, string("")); - vec.Resize(1); - SetAt(loctestnum, loctesterr, vec, true, 0, string("X")); - - movvec.Clear(); - Empty(loctestnum, loctesterr, movvec, true); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVector(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - stestVectorInt(loctestnum, loctesterr); - stestVectorDouble(loctestnum, loctesterr); - stestVectorString(loctestnum, loctesterr); - testnum += loctestnum; - testerr += loctesterr; - cout << endl << "Exercise 1 - Vector (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; -} - -/* ************************************************************************** */ - -void stestListInt(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of List Test:" << endl; - try { - lasd::List lst; - Empty(loctestnum, loctesterr, lst, true); - Size(loctestnum, loctesterr, lst, true, 0); - - GetFront(loctestnum, loctesterr, lst, false, 0); - GetBack(loctestnum, loctesterr, lst, false, 0); - - Exists(loctestnum, loctesterr, lst, false, 0); - - MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 0); - FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 0); - - RemoveFromFront(loctestnum, loctesterr, lst, false); - FrontNRemove(loctestnum, loctesterr, lst, false, 0); - - InsertAtBack(loctestnum, loctesterr, lst, true, 4); - InsertAtFront(loctestnum, loctesterr, lst, true, 5); - InsertAtFront(loctestnum, loctesterr, lst, true, 9); - InsertAtBack(loctestnum, loctesterr, lst, true, 2); - InsertAtFront(loctestnum, loctesterr, lst, true, 1); - - GetFront(loctestnum, loctesterr, lst, true, 1); - GetBack(loctestnum, loctesterr, lst, true, 2); - SetFront(loctestnum, loctesterr, lst, true, 2); - SetBack(loctestnum, loctesterr, lst, true, 6); - - GetAt(loctestnum, loctesterr, lst, true, 3, 4); - SetAt(loctestnum, loctesterr, lst, true, 3, 3); - - Exists(loctestnum, loctesterr, lst, false, 4); - - MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 25); - FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0, 1, 1620); - - RemoveFromFront(loctestnum, loctesterr, lst, true); - FrontNRemove(loctestnum, loctesterr, lst, true, 9); - FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0, 1, 90); - - lasd::List coplst(lst); - EqualList(loctestnum, loctesterr, lst, coplst, true); - MapPreOrder(loctestnum, loctesterr, lst, true, &MapIncrement, 0); - NonEqualList(loctestnum, loctesterr, lst, coplst, true); - - InsertAtFront(loctestnum, loctesterr, lst, true, 0); - InsertAtBack(loctestnum, loctesterr, lst, true, 0); - NonEqualList(loctestnum, loctesterr, lst, coplst, true); - coplst = lst; - EqualList(loctestnum, loctesterr, lst, coplst, true); - - RemoveFromFront(loctestnum, loctesterr, coplst, true); - FrontNRemove(loctestnum, loctesterr, coplst, true, 6); - coplst = std::move(lst); - FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0, 0, 11); - FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldAdd, 0, 0, 17); - - lasd::List movlst(std::move(lst)); - MapPreOrder(loctestnum, loctesterr, movlst, true, &MapIncrement, 0); - FoldPreOrder(loctestnum, loctesterr, movlst, true, &FoldAdd, 0, 0, 14); - - movlst.Clear(); - Empty(loctestnum, loctesterr, movlst, true); - Size(loctestnum, loctesterr, movlst, true, 0); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestListDouble(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of List Test:" << endl; - try { - lasd::List lst; - Empty(loctestnum, loctesterr, lst, true); - Size(loctestnum, loctesterr, lst, true, 0); - - InsertAtBack(loctestnum, loctesterr, lst, true, -2.5); - InsertAtBack(loctestnum, loctesterr, lst, true, 2.5); - - lst.Clear(); - - InsertAtBack(loctestnum, loctesterr, lst, true, 0.5); - InsertAtFront(loctestnum, loctesterr, lst, true, 3.3); - InsertAtFront(loctestnum, loctesterr, lst, true, 5.5); - InsertAtBack(loctestnum, loctesterr, lst, true, 1.1); - - GetFront(loctestnum, loctesterr, lst, true, 5.5); - GetBack(loctestnum, loctesterr, lst, true, 1.1); - - Exists(loctestnum, loctesterr, lst, false, 0.0); - - MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - MapPostOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldAdd, 0.0, 0.0, 10.4); - FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldMultiply, 0.0, 1.0, 9.9825); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestListString(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of List Test:" << endl; - try { - lasd::List lst; - Empty(loctestnum, loctesterr, lst, true); - Size(loctestnum, loctesterr, lst, true, 0); - - InsertAtFront(loctestnum, loctesterr, lst, true, string("A")); - InsertAtBack(loctestnum, loctesterr, lst, true, string("B")); - - GetFront(loctestnum, loctesterr, lst, true, string("A")); - GetBack(loctestnum, loctesterr, lst, true, string("B")); - - Exists(loctestnum, loctesterr, lst, true, string("B")); - - MapPreOrder(loctestnum, loctesterr, lst, true, &MapStringAppend, string(" ")); - MapPreOrder(loctestnum, loctesterr, lst, true, &MapPrint, 0); - FoldPreOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XA B ")); - FoldPostOrder(loctestnum, loctesterr, lst, true, &FoldStringConcatenate, string(""), string("X"), string("XB A ")); - - Exists(loctestnum, loctesterr, lst, false, string("B")); - - lasd::List coplst(lst); - EqualList(loctestnum, loctesterr, lst, coplst, true); - RemoveFromFront(loctestnum, loctesterr, coplst, true); - NonEqualList(loctestnum, loctesterr, lst, coplst, true); - - lst = coplst; - EqualList(loctestnum, loctesterr, lst, coplst, true); - InsertAtBack(loctestnum, loctesterr, lst, true, string("A")); - InsertAtFront(loctestnum, loctesterr, lst, true, string("C")); - NonEqualList(loctestnum, loctesterr, lst, coplst, true); - - coplst = std::move(lst); - FoldPreOrder(loctestnum, loctesterr, coplst, true, &FoldStringConcatenate, string(""), string("?"), string("?CB A")); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestList(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - stestListInt(loctestnum, loctesterr); - stestListDouble(loctestnum, loctesterr); - stestListString(loctestnum, loctesterr); - testnum += loctestnum; - testerr += loctesterr; - cout << endl << "Exercise 1 - List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; -} - -/* ************************************************************************** */ - -void stestVectorListInt(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector/List Test:" << endl; - try { - lasd::Vector vec(3); - SetAt(loctestnum, loctesterr, vec, true, 0, -1); - SetAt(loctestnum, loctesterr, vec, true, 1, 0); - SetAt(loctestnum, loctesterr, vec, true, 2, 1); - - lasd::List lst; - InsertAtFront(loctestnum, loctesterr, lst, true, 1); - InsertAtFront(loctestnum, loctesterr, lst, true, 0); - InsertAtFront(loctestnum, loctesterr, lst, true, -1); - - lasd::Vector copvec(lst); - EqualVector(loctestnum, loctesterr, vec, copvec, true); - lasd::Vector copvecx(vec); - EqualVector(loctestnum, loctesterr, copvecx, copvec, true); - - lasd::List coplst(vec); - EqualList(loctestnum, loctesterr, lst, coplst, true); - lasd::List coplstx(lst); - EqualList(loctestnum, loctesterr, coplstx, coplst, true); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVectorListDouble(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector/List Test:" << endl; - try { - lasd::Vector vec(3); - SetAt(loctestnum, loctesterr, vec, true, 0, -0.5); - SetAt(loctestnum, loctesterr, vec, true, 1, 0.0); - SetAt(loctestnum, loctesterr, vec, true, 2, 0.5); - - lasd::List lst; - InsertAtBack(loctestnum, loctesterr, lst, true, -0.5); - InsertAtBack(loctestnum, loctesterr, lst, true, 0.0); - InsertAtBack(loctestnum, loctesterr, lst, true, 0.5); - - lasd::Vector copvec(lst); - EqualVector(loctestnum, loctesterr, vec, copvec, true); - lasd::Vector copvecx(vec); - EqualVector(loctestnum, loctesterr, copvecx, copvec, true); - - lasd::List coplst(vec); - EqualList(loctestnum, loctesterr, lst, coplst, true); - lasd::List coplstx(lst); - EqualList(loctestnum, loctesterr, coplstx, coplst, true); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVectorListString(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - cout << endl << "Begin of Vector/List Test:" << endl; - try { - lasd::Vector vec(3); - SetAt(loctestnum, loctesterr, vec, true, 0, string("A")); - SetAt(loctestnum, loctesterr, vec, true, 1, string("B")); - SetAt(loctestnum, loctesterr, vec, true, 2, string("C")); - - lasd::List lst; - InsertAtFront(loctestnum, loctesterr, lst, true, string("B")); - InsertAtBack(loctestnum, loctesterr, lst, true, string("C")); - InsertAtFront(loctestnum, loctesterr, lst, true, string("A")); - - lasd::Vector copvec(lst); - EqualVector(loctestnum, loctesterr, vec, copvec, true); - lasd::Vector copvecx(vec); - EqualVector(loctestnum, loctesterr, copvecx, copvec, true); - - lasd::List coplst(vec); - EqualList(loctestnum, loctesterr, lst, coplst, true); - lasd::List coplstx(lst); - EqualList(loctestnum, loctesterr, coplstx, coplst, true); - } catch(...) { - loctestnum++; loctesterr++; - cout << endl << "Unmanaged error! " << endl; - } - cout << "End of Vector/List Test! (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; - testnum += loctestnum; - testerr += loctesterr; -} - -void stestVectorList(uint& testnum, uint& testerr) { - uint loctestnum = 0, loctesterr = 0; - stestVectorListInt(loctestnum, loctesterr); - stestVectorListDouble(loctestnum, loctesterr); - stestVectorListString(loctestnum, loctesterr); - testnum += loctestnum; - testerr += loctesterr; - cout << endl << "Exercise 1 - Vector/List (Errors/Tests: " << loctesterr << "/" << loctestnum << ")" << endl; -} - -/* ************************************************************************** */ - -void testSimpleExercise1() { - uint testnum = 0, testerr = 0; - stestVector(testnum, testerr); - stestList(testnum, testerr); - stestVectorList(testnum, testerr); - cout << endl << "Exercise 1 (Simple Test) (Errors/Tests: " << testerr << "/" << testnum << ")" << endl; -} diff --git a/librerie/exercise1old/zlasdtest/exercise1/test.hpp b/librerie/exercise1old/zlasdtest/exercise1/test.hpp deleted file mode 100644 index c151dcf..0000000 --- a/librerie/exercise1old/zlasdtest/exercise1/test.hpp +++ /dev/null @@ -1,13 +0,0 @@ - -#ifndef EX1TEST_HPP -#define EX1TEST_HPP - -/* ************************************************************************** */ - -void testSimpleExercise1(); - -void testFullExercise1(); - -/* ************************************************************************** */ - -#endif diff --git a/librerie/exercise1old/zlasdtest/list/list.hpp b/librerie/exercise1old/zlasdtest/list/list.hpp deleted file mode 100644 index 94fbe48..0000000 --- a/librerie/exercise1old/zlasdtest/list/list.hpp +++ /dev/null @@ -1,92 +0,0 @@ - -#ifndef LISTTEST_HPP -#define LISTTEST_HPP - -#include "../../list/list.hpp" - -/* ************************************************************************** */ - -template -void InsertAtFront(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Insert at the front of the list the value \"" << val << "\": "; - lst.InsertAtFront(val); - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void RemoveFromFront(uint& testnum, uint& testerr, lasd::List& lst, bool chk) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Remove from the list of \"" << lst.Front() << "\": "; - lst.RemoveFromFront(); - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void FrontNRemove(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " FrontNRemove from the list of \"" << lst.Front() << "\": "; - std::cout << ((tst = ((lst.FrontNRemove() == val) == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::length_error exc) { - std::cout << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void InsertAtBack(uint& testnum, uint& testerr, lasd::List& lst, bool chk, const Data& val) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " Insert at the back of the list the value \"" << val << "\": "; - lst.InsertAtBack(val); - std::cout << ((tst = chk) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void EqualList(uint& testnum, uint& testerr, const lasd::List& lst1, const lasd::List& lst2, bool chk) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 == lst2)) ? "" : "not ") << "equal: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void NonEqualList(uint& testnum, uint& testerr, const lasd::List& lst1, const lasd::List& lst2, bool chk) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The two lists are " << ((tst = (lst1 != lst2)) ? "not " : "") << "equal: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -#endif diff --git a/librerie/exercise1old/zlasdtest/test.cpp b/librerie/exercise1old/zlasdtest/test.cpp deleted file mode 100644 index faa5bf0..0000000 --- a/librerie/exercise1old/zlasdtest/test.cpp +++ /dev/null @@ -1,17 +0,0 @@ - -#include "./exercise1/test.hpp" - -/* ************************************************************************** */ - -#include - -using namespace std; - -/* ************************************************************************** */ - -void lasdtest() { - cout << endl << "~*~#~*~ Welcome to the LASD Test Suite ~*~#~*~ " << endl; - testSimpleExercise1(); - testFullExercise1(); - cout << endl << "Goodbye!" << endl; -} diff --git a/librerie/exercise1old/zlasdtest/test.hpp b/librerie/exercise1old/zlasdtest/test.hpp deleted file mode 100644 index a2fca61..0000000 --- a/librerie/exercise1old/zlasdtest/test.hpp +++ /dev/null @@ -1,11 +0,0 @@ - -#ifndef LASDTEST_HPP -#define LASDTEST_HPP - -/* ************************************************************************** */ - -void lasdtest(); - -/* ************************************************************************** */ - -#endif diff --git a/librerie/exercise1old/zlasdtest/vector/vector.hpp b/librerie/exercise1old/zlasdtest/vector/vector.hpp deleted file mode 100644 index bb0ccf6..0000000 --- a/librerie/exercise1old/zlasdtest/vector/vector.hpp +++ /dev/null @@ -1,37 +0,0 @@ - -#ifndef VECTORTEST_HPP -#define VECTORTEST_HPP - -#include "../../vector/vector.hpp" - -/* ************************************************************************** */ - -template -void EqualVector(uint& testnum, uint& testerr, const lasd::Vector& vec1, const lasd::Vector& vec2, bool chk) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 == vec2)) ? "" : "not ") << "equal: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -template -void NonEqualVector(uint& testnum, uint& testerr, const lasd::Vector& vec1, const lasd::Vector& vec2, bool chk) { - bool tst; - testnum++; - try { - std::cout << " " << testnum << " The two vectors are " << ((tst = (vec1 != vec2)) ? "not " : "") << "equal: "; - std::cout << ((tst = (tst == chk)) ? "Correct" : "Error") << "!" << std::endl; - } catch(std::exception exc) { - std::cout << "\"" << exc.what() << "\": " << ((tst = !chk) ? "Correct" : "Error") << "!" << std::endl; - } - testerr += (1 - (uint) tst); -} - -/* ************************************************************************** */ - -#endif diff --git a/librerie/exercise1old/zmytest/test.cpp b/librerie/exercise1old/zmytest/test.cpp deleted file mode 100644 index ae73e4d..0000000 --- a/librerie/exercise1old/zmytest/test.cpp +++ /dev/null @@ -1,70 +0,0 @@ -void menu(){ - unsigned short int choice; - DataStructure chosenDataStructure; - DataType chosenDataType; - do{ - std::cout<<"1. Use your tests (to be used by the professor)"<>std::ws; - std::cin>>choice; - }while(choice!=1 && choice!=2); - - switch(choice){ - case 1: - lasdtest(); - break; - case 2: - chosenDataStructure = ChooseDataStructure(); - chosenDataType = ChooseDataType(); - break; - default: - std::cout<<"An error has occurred"<>std::ws; - std::cin>>choice; - }while(choice!=1 && choice!=2); - if(choice == 1) - return DataStructure::vector; - else if(choice == 2) - return DataStructure::list; -} - -DataType ChooseDataType(){ - unsigned short int choice; - do{ - std::cout<<"1. Integer"<>std::ws; - std::cin>>choice; - }while(!(choice>0 && choice<4)); - if(choice==1) - return DataType::integer; - else if(choice==2) - return DataType::ddouble; - else if(choice==3) - return DataType::sstring; -} -void UseChosenType(DataStructure chosenDataStructure, DataType chosenDataType){ - std::cout<<"\tTest on "; - if(chosenDataStructure == DataStructure::vector) - std::cout<<"vector of "; - else if(chosenDataStructure == DataStructure::list) - std::cout<<"list of "; - - if(chosenDataType == DataType::integer) - std::cout<<" integers"< GenerateRandomStructure(const ulong&); -void ViewElement(const LinearContainer&); -void PrintAllElements(const LinearContainer&); -void PrintElement(Data&, void*); // funzione richiamata dalla map -void CheckExists(const LinearContainer&); -void ChooseFoldFunction(const LinearContainer&); -void SumLessThan(const LinearContainer&, const ulong&); -void SumLessThanFold(int&, const void*, void*); -void ProductMoreThan(const LinearContainer&, const ulong&); -void ProductMoreThanFold(float&, const void*, void*); -void ConcatStringLessThan(const LinearContainer&, const ulong&); -void ConcatStringLessThanFold(string&, const void*, void*); - -//7 -void ChooseMapFunction(const LinearContainer); -void DoubleN(const LinearContainer&, const ulong&); -void DoubleNMap(int&, void*); - -void SquareN(const LinearContainer&, const ulong&); -void SquareNMap(float&, void*); - -void Uppercase(const LinearContainer&, const ulong&); -void UppercaseMap(string&, void*); - - -#endif