utility.h

Go to the documentation of this file.

// n2p2 - A neural network potential package
// Copyright (C) 2018 Andreas Singraber (University of Vienna)
//
// This program 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.
//
// This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef UTILITY_H
#define UTILITY_H
 
#include <cstdio>           // FILE
#include <fstream>          // std::ofstream
#include <map>              // std::map
#include <sstream>          // std::stringstream
#include <stdexcept>        // std::range_error
#include <string>           // std::string
#include <vector>           // std::vector
#include <unordered_map>    // std::unordered_map
#include <algorithm>        // std::find
 
namespace nnp
{
 
std::vector<std::string> split(std::string const& input,
                               char               delimiter = ' ');
std::string              trim(std::string const& line,
                              std::string const& whitespace = " \t");
std::string              reduce(std::string const& line,
                                std::string const& whitespace = " \t",
                                std::string const& fill = " ");
std::string              pad(std::string const& input,
                             std::size_t        num,
                             char               fill = ' ',
                             bool               right = true);
std::string              strpr(const char* format, ...);
std::string              cap(std::string word);
std::vector<std::string> createFileHeader(
                            std::vector<std::string> const& title,
                            std::vector<std::size_t> const& colLength,
                            std::vector<std::string> const& colName,
                            std::vector<std::string> const& colInfo,
                            char const&                     commentChar = '#');
void                     appendLinesToFile(
                                         std::ofstream&                 file,
                                         std::vector<std::string> const lines);
void                     appendLinesToFile(
                                         FILE* const&                   file,
                                         std::vector<std::string> const lines);
std::map<std::size_t,
         std::vector<double>>
                         readColumnsFromFile(
                                       std::string fileName,
                                       std::vector<std::size_t> columns,
                                       char                     comment = '#');
template<typename K, typename V>
V const&                 safeFind(std::map<K, V> const&           stdMap,
                                  typename
                                  std::map<K, V>::key_type const& key)
{
    if (stdMap.find(key) == stdMap.end())
    {
        std::stringstream message;
        message << "ERROR: No map entry found for key \"";
        message << key;
        message << "\".\n";
        throw std::range_error(message.str());
    }
    return stdMap.find(key)->second;
}
 
template<typename T>
bool                    vectorContains(std::vector<T> const& stdVec,
                                       T value)
{
    return (std::find(stdVec.begin(), stdVec.end(), value) != stdVec.end());
}
template<typename T, typename U>
bool                    unorderedMapContainsKey(
                                    std::unordered_map<T, U> const& stdMap,
                                    T key)
{
    return ( stdMap.find(key) != stdMap.end() );
}
 
template<typename T>
bool                     comparePointerTargets(T* lhs, T* rhs)
{
    return ((*lhs) < (*rhs));
}
 
double                   pow_int(double x, int n);
 
}
 
#endif