utility.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2014 Micah C Chambers (micahc.vt@gmail.com)
 *
 * NPL is free software: you can redistribute it and/or modify it under the
 * terms of the BSD 2-Clause License available in LICENSE or at
 * http://opensource.org/licenses/BSD-2-Clause
 *
 * @file utility.h File with random utilities, for string processing, for
 * determining basic filename information (basename/dirname).
 *
 *****************************************************************************/
#ifndef UTILITY_FUNCTIONS_H
#define UTILITY_FUNCTIONS_H

#include <string>
#include <cmath>
#include <list>
#include <vector>

#define __FUNCTION_STR__ std::string(__PRETTY_FUNCTION__)

namespace npl {

std::string dirname(std::string path);

bool isTxt(std::string filename);

bool fileExists(std::string filename);

std::string chomp(std::string str);

std::vector<std::string> parseLine(std::string line, std::string delim);

std::vector<std::vector<std::string>> readStrCSV(std::string filename,
        char& delim, char comment = '#');

std::vector<std::vector<double>> readNumericCSV(std::string filename,
            char comment = '#');

double gammaPDF(double x, double k, double theta);


double cannonHrf(double t, double rdelay, double udelay, double rdisp,
        double udisp, double puRatio, double onset, double total);

double cannonHrf(double t);

std::vector<double> getRegressor(std::vector<std::vector<double>>& spec,
        double tr, size_t ntimes, double t0);

std::vector<double> getRegressor(std::vector<std::vector<double>>& spec,
        double tr, size_t ntimes, double t0);

void boldsim(size_t len, double* iobuff, double dt, double learn);

void convolve(std::vector<double>& signal, double(*foo)(double),
        double tr, double length);

inline
double fwhm_to_sd(double fwhm)
{
  return fwhm/(2*sqrt(2*log(2)));
}

inline
double sd_to_fwhm(double sd)
{
  return sd*(2*sqrt(2*log(2)));
}

class MemMap
{
public:
    MemMap(std::string fn, size_t bsize);

    MemMap(std::string fn, bool writeable=false);

    MemMap() : m_size(0), m_fd(0), m_data(NULL) {};

    int64_t openNew(std::string fn, size_t bsize);

    int64_t openExisting(std::string fn, bool writeable, bool quiet = true);

    bool isopen() { return m_size > 0; };

    void close();

    ~MemMap();

    void* data() { return m_data; };

    const void* data() const { return m_data; };

    int64_t size() { return m_size; };
private:

    int64_t m_size;
    int m_fd;
    void* m_data;
};

}
#endif // UTILITY_FUNCTIONS_H