customOperators.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
 \ *---------------------------------------------------------------------------*/
 
#ifndef __CUSTOMOPERATORS_HH__
#define __CUSTOMOPERATORS_HH__
 
#include <cmath>
#include <vector>
#include <array>
#include <algorithm>
 
#include "mimmoTypeDef.hpp"
#include <bitpit_patchkernel.hpp>
 
 
 
std::array<double, 3> operator-(const bitpit::Vertex &v1, const bitpit::Vertex &v2);
 
int countSubstring(const std::string& str, const std::string& sub);
 
 
template <class T>
void freeContainer (std::vector<T> & t){
        t.swap(std::vector<T>());
}
 
template <class T>
T summing_Vector(std::vector<T> & t){
    T result = t[0];
    std::size_t size = t.size();
    for(int i=1; i<size; ++i){
        result += t[i];
    }
    return  result;
}
 
bool inline logical_summing(bool &root, bool & target, bool * policy){
    bool result;
    if(policy[0]) result = target;
    if(policy[1]) result = root + target;
 
    if(policy[2]) {
        result = root - target;
        //further check if root is 0 and target is 1.
        // -1 is read as 1; I want to keep him as 0;
        if(result) result = result - target;
    }
    return result;
};
 
int inline logical_summing(int &root, int &target, bool policy){
    bool result;
    if(policy){
        result = (bool)root + (bool)target;
    }else{
        result = (bool)root - (bool)target;
        //further check if root is 0 and target is 1.
        // -1 is read as 1; I want to keep him as 0;
        if(result) result = result - (bool)target;
    }
    return  (int)result;
};
 
template <class T>
T getSign (T & t){
    T result = 1;
    if(t < 0) result= -1 * result;
    return  result;
}
 
template <class T>
int  inline posVectorFind( std::vector<T>   &vect,  T& target){
    int pos = -1;
    typename std::vector< T >::iterator it_find = std::find(vect.begin(),vect.end(),target);
    if (it_find!=vect.end())  {
        pos = std::distance(vect.begin(),it_find);
    }
 
return pos;
};
 
template <class T, size_t d >
int  inline posVectorFind( std::array<T, d> &vect, T& target){
    int pos = -1;
    typename std::array< T,d >::iterator it_find = std::find(vect.begin(),vect.end(),target);
    if (it_find!=vect.end()){
        pos = std::distance(vect.begin(),it_find);
    }
    return pos;
};
 
template <class T>
bool inline checkVectorFind( std::vector<T> &vect, T& target){
    bool check = false;
    typename std::vector< T >::iterator it_find = std::find(vect.begin(),vect.end(),target);
    if (it_find!=vect.end())    check=true;
    return check;
};
 
template <class T, size_t d>
bool inline checkVectorFind( std::array<T,d> &vect, T& target){
    bool check = false;
    typename std::array< T,d >::iterator it_find = std::find(vect.begin(),vect.end(),target);
    if (it_find!=vect.end()) check=true;
    return check;
};
 
template <class T, size_t d>
std::vector<T> inline conVect(std::array<T, d> & origin ){
    std::vector<T> result(d);
    for(size_t i=0; i<d; ++i)
        result[i] = origin[i];
    return  result;
}
 
template <class T, size_t d>
std::array<T,d> inline conArray(std::vector<T> & origin ){
    std::array<T,d> result;
    for(size_t i=0; i<d; ++i)
        result[i] = origin[i];
    return  result;
}
 
template <class T, size_t d>
std::vector< std::vector < T > > inline conVect(std::vector< std::array<T, d> > & origin ){
    std::vector<std::vector<T> > result(origin.size());
    for(size_t i=0; i<origin.size(); ++i)
        result[i] = conVect(origin[i]);
    return  result;
}
 
template <class T, size_t d>
std::vector< std::array< T, d > > inline conArray(std::vector<std::vector<T> > & origin ){
    std::vector< std::array<T,d> > result(origin.size());
    for(size_t i=0; i<origin.size(); ++i)
        result[i] = conArray< T, d>(origin[i]);
    return  result;
}
 
template <class T>
T findPosition(T & value, std::vector<T> & source){
    T result = -1;
    typename std::vector< T >::iterator itV = std::find(source.begin(), source.end(), value);
    if(itV != source.end())
        result = std::distance(source.begin(), itV);
    return  result;
};
 
 
template <class T>
std::vector< T > getVectorSubset(int i, int j, std::vector<T> & source){
    std::vector < T> result;
    int counter = 0;
    if(i >= (int)source.size() || j < 0)    return  result;
 
    result.resize(source.size());
 
    // check your controlling indices
    int maxElement = source.size() -1;
    i = std::max(std::min(i,maxElement), 0);
    j = std::max(std::min(j,maxElement), 0);
 
    if(i>=j){
        for(int k=i; k<source.size(); ++k ){
            result[counter] = source[k];
            ++counter;
        }
        for(int k=0; k<j; ++k ){
            result[counter] = source[k];
            ++counter;
        }
    }else{
        for(int k=i; k<j; ++k ){
            result[counter] = source[k];
            ++counter;
        }
    }
    result.resize(counter);
    return  result;
}
 
template <class T>
void fillVectorSubset(int i, int j, std::vector<T> & source, T cValue){
    if(i >= source.size() || j < 0) return;
 
    // check your controlling indices
    int maxElement = source.size() -1;
    i = std::max(std::min(i,maxElement), 0);
    j = std::max(std::min(j,maxElement), 0);
 
    if(i>=j){
        for(int k=i; k<source.size(); ++k ){
            source[k] = cValue;
        }
        for(int k=0; k<j; ++k ){
            source[k] = cValue;
        }
    }else{
        for(int k=i; k<j; ++k ){
            source[k] = cValue;
        }
    }
    return;
}
 
#endif //__CUSTOMOPERATORS_HH__