support.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// MARTY is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef SUPPORT_H_INCLUDED
#define SUPPORT_H_INCLUDED

#include <cmath>
#include <string>
#include <string_view>
#include <sstream>
#include <vector>
#include <functional>


template<class T>
std::string toString(T obj)
{
    std::ostringstream sout;
    sout << obj;
    return sout.str();
}

namespace csl {

int PGCD(double a, double b);

long long int PGCD(long long int a, long long int b);

int PGCD(int a, int b);

int internal_PGCD(long long int a, long long int b);

long long int sgn(long long int a); 

int sgn(int a); 

int sgn(double a); 

double factorial(int n);

long long int internal_factorial(long long int n);

int compare(std::string_view a, std::string_view b);

bool operator>(const std::string& a, const std::string& b);

bool operator<(const std::string& a, const std::string& b);

bool operator>=(const std::string& a, const std::string& b);

bool operator<=(const std::string& a, const std::string& b);

std::vector<size_t> range(size_t n);

std::vector<size_t> range(size_t i, size_t n);

std::vector<size_t> range(size_t i, size_t n, size_t step);

template <typename T>
bool comparePlaceIndependant(std::vector<T> A,
                             std::vector<T> B)
{
    const size_t size = A.size();
    if (size != B.size())
        return false;
    std::vector<int> indicesLeft(size);
    for (size_t i = 0; i != size; ++i) 
        indicesLeft[i] = i;

    for (size_t iA = 0; iA != size; ++iA) {
        bool matched = false;
        for (size_t iLeft = 0; iLeft != indicesLeft.size(); ++iLeft)  {
            size_t iB = indicesLeft[iLeft];
            if (A[iA] == B[iB]) {
                matched = true;
                indicesLeft.erase(indicesLeft.begin()+iLeft);
                break;
            }
        }
        if (not matched)
            return false;
    }

    return true;
}
    
template <typename T>
bool partialComparePlaceIndependant(std::vector<T> A, std::vector<T> B)
{
    if (A.size() < B.size())
        return false;
    std::vector<int> indicesLeft(B.size());
    for (size_t i = 0; i != B.size(); ++i) 
        indicesLeft[i] = i;

    for (size_t iA = 0; iA != A.size(); ++iA) {
        for (size_t iLeft = 0; iLeft != indicesLeft.size(); ++iLeft)  {
            size_t iB = indicesLeft[iLeft];
            if (A[iA] == B[iB]) {
                indicesLeft.erase(indicesLeft.begin()+iLeft);
                break;
            }
        }
    }

    return (indicesLeft.empty());
}

} // End of namespace csl

#endif