Utility.hpp

Go to the documentation of this file.

#ifndef UTILITY_HPP
#define UTILITY_HPP

#include "constant.hpp"

double * vector2array(const std::vector<double> &a);
double * vector2array(const std::vector<double> &a, const unsigned size);
int * vector2array(const std::vector<int> &a);
double ** vector2array(const std::vector<double> &a, const unsigned M, const unsigned N);
void deleteArray(double* data);
void deleteArray(double** data);
std::vector<std::vector<double> > vector2vector(const std::vector<double> &a, const int N, const int M);
std::vector<double> array2vector(const double *a, const int size);
std::vector<std::vector<double> > array2vector(const double *a, const int N, const int M);

double str2num(const std::string &s);

std::string num2str(const double x);

double matlabfmod(const double x, const double y);

std::string getRandomFileName(std::string &prefix);

int getNextPower(int N, int base);


void writeToTxtFile(const std::string file_name, const std::vector<double> &data);
void writeToTxtFile(const std::string file_name, const std::vector<std::vector<double> > &data);
double bandwidthToGaussianStdDev(unsigned bandwidth_defn, double bandwidth);

std::vector<double> solveTridiagonalSystem(const std::vector<double> &a,
                                           const std::vector<double> &b,
                                           const std::vector<double> &c,
                                           const std::vector<double> &d);
std::vector<double> solveLinearSystem(const std::vector<std::vector<double> > &S,
                                      const std::vector<double> &rhs);

std::vector<double> cubic_spline_interp(const std::vector<double> &x,
                                        const std::vector<double> &y,
                                        const std::vector<double> &xi);

double linear_interp(const std::vector<double> &x,
                     const std::vector<double> &y,
                     const std::vector<std::vector<double> > &z,
                     const double xi,
                     const double yi);


void convertIndex(const int index, const int nZ, int j, int k);

void convertIndex(const int index, const int nY, const int nZ, int i, int j, int k);

std::vector<int>    getBilinearInterpolationIndex(const std::vector<double> &z,
                                                  const double zi);

std::vector<int>    getBilinearInterpolationIndex(const std::vector<double> &y,
                                                  const std::vector<double> &z,
                                                  const double yi,
                                                  const double zi);
std::vector<int>    getBilinearInterpolationIndex(const std::vector<double> &x,
                                                  const std::vector<double> &y,
                                                  const std::vector<double> &z,
                                                  const double xi,
                                                  const double yi,
                                                  const double zi);

std::vector<double> getBilinearInterpolationCoefficient(const std::vector<double> &z,
                                                        const double zi);

std::vector<double> getBilinearInterpolationCoefficient(const std::vector<double> &y,
                                                        const std::vector<double> &z,
                                                        const double yi,
                                                        const double zi);
std::vector<double> getBilinearInterpolationCoefficient(const std::vector<double> &x,
                                                        const std::vector<double> &y,
                                                        const std::vector<double> &z,
                                                        const double xi,
                                                        const double yi,
                                                        const double zi);
std::vector<std::vector<double> > cubic_spline_interp(const std::vector<double> &x,
                                                      const std::vector<double> &y,
                                                      const std::vector<std::vector<double> > &z,
                                                      const std::vector<double> &xi,
                                                      const std::vector<double> &yi);

std::vector<double> poly_interp(const std::vector<double> &x,
                                const std::vector<double> &y,
                                const std::vector<double> &xi);
  
int findEqual(const std::vector<double> &reference, const double x, int i, int j);
  
std::vector<int> findEqual(const std::vector<double> &reference, const double x);
std::vector<int> findEqual(const std::vector<std::vector<double> > &reference, const double x);

bool approximatelyEqual(const double a, const double b, const double epsilon);

bool essentiallyEqual(const double a, const double b, const double epsilon);

bool definitelyGreaterThan(const double a, const double b, const double epsilon);

bool definitelyLessThan(const double a, const double b, const double epsilon);

std::string secondToTime(int seconds);

std::vector<double> estimateAmplitudePhase(const std::vector<double> &data, const double frequency, const double delta_t);
double cot(const double x);
double acot(const double x);

bool isEven(unsigned n);
bool isOdd(unsigned n);

#endif