utils.h File Reference

#include <iostream>
#include <vector>
#include <Eigen/Dense>
#include <gsl/gsl>
#include <numeric>
#include <random>

Go to the source code of this file.

Functions
template<typename Matrix >
void	removeRow (Matrix &matrix, gsl::index rowToRemove)
template<typename Matrix >
void	removeColumn (Matrix &matrix, gsl::index colToRemove)
template<typename T >
void	select (std::vector< T > &result, const std::vector< T > &in, const std::vector< typename std::vector< T >::size_type > &s)
std::tuple< std::vector< gsl::index >, std::vector< gsl::index > >	TrainTestSplit (gsl::index nrows, double testRatio=0.3)
std::tuple< std::vector< gsl::index >, std::vector< gsl::index > >	TrainTestSplit (std::vector< gsl::index > inputIdx, double testRatio=0.3)
template<typename T >
std::vector< T >	linspace (T start_in, T end_in, int num_in)
template<typename T >
void	print_vector (std::vector< T > vec)

Function Documentation

linspace()

template<typename T >

std::vector<T> linspace	(	T	start_in,
		T	end_in,
		int	num_in
	)

Definition at line 81 of file utils.h.

{
 
    std::vector<T> linspaced;
 
    double start = static_cast<double>(start_in);
    double end = static_cast<double>(end_in);
    double num = static_cast<double>(num_in);
 
    if (num == 0) { return linspaced; }
    if (num == 1)
    {
        linspaced.push_back(start);
        return linspaced;
    }
 
    double delta = (end - start) / (num - 1);
    for(int i=0; i < num-1; ++i)
    {
        linspaced.push_back(start + delta * i);
    }
    linspaced.push_back(end);
    return linspaced;
}

print_vector()

template<typename T >

void print_vector

(

std::vector< T >

vec

)

Definition at line 107 of file utils.h.

{
    std::cout << "size: " << vec.size() << std::endl;
    for (T & d : vec)
        std::cout << d << " ";
    std::cout << std::endl;
}

removeColumn()

template<typename Matrix >

void removeColumn	(	Matrix &	matrix,
		gsl::index	colToRemove
	)

Definition at line 22 of file utils.h.

{
    gsl::index numRows = matrix.rows();
    gsl::index numCols = matrix.cols()-1;
 
    if( colToRemove < numCols )
        matrix.block(0,colToRemove,numRows,numCols-colToRemove) = matrix.block(0,colToRemove+1,numRows,numCols-colToRemove).eval();
 
    matrix.conservativeResize(numRows,numCols);
}

removeRow()

template<typename Matrix >

void removeRow	(	Matrix &	matrix,
		gsl::index	rowToRemove
	)

Definition at line 11 of file utils.h.

{
    gsl::index numRows = matrix.rows()-1;
    gsl::index numCols = matrix.cols();
 
    if( rowToRemove < numRows )
        matrix.block(rowToRemove,0,numRows-rowToRemove,numCols) = matrix.block(rowToRemove+1,0,numRows-rowToRemove,numCols).eval();
 
    matrix.conservativeResize(numRows,numCols);
}

select()

template<typename T >

void select	(	std::vector< T > &	result,
		const std::vector< T > &	in,
		const std::vector< typename std::vector< T >::size_type > &	s
	)

Definition at line 34 of file utils.h.

                                                                                                              {
    result.reserve(s.size());
    std::transform(s.begin(), s.end(), std::back_inserter(result),
                   [&in](typename std::vector<T>::size_type idx) {
                       return in.at(idx);
                   });
}

TrainTestSplit() [1/2]

std::tuple<std::vector<gsl::index>,std::vector<gsl::index> > TrainTestSplit	(	gsl::index	nrows,
		double	testRatio = 0.3
	)

Definition at line 42 of file utils.h.

                                                                                                      {
    assert(testRatio>=0 && testRatio<=1);
    gsl::index ntest = (gsl::index) nrows*(testRatio);
    gsl::index ntrain = nrows - ntest;
    std::vector<int> idx(nrows);
    std::iota(idx.begin(), idx.end(), 0);
 
    std::vector<gsl::index> trainIdx, testIdx;
    trainIdx.resize(ntrain);
    testIdx.resize(ntest);
    std::sample(idx.begin(), idx.end(), std::back_inserter(testIdx),
                ntest, std::mt19937{std::random_device{}()});
    std::sort(testIdx.begin(),testIdx.end());
    std::set_difference(idx.begin(), idx.end(), trainIdx.begin(), trainIdx.end(),
                        std::inserter(testIdx, testIdx.begin()));
    return {trainIdx,testIdx};
}

TrainTestSplit() [2/2]

std::tuple<std::vector<gsl::index>,std::vector<gsl::index> > TrainTestSplit	(	std::vector< gsl::index >	inputIdx,
		double	testRatio = 0.3
	)

Definition at line 60 of file utils.h.

                                                                                                                    {
    assert(testRatio>=0 && testRatio<=1);
    gsl::index nrows = inputIdx.size();
    gsl::index ntest = (gsl::index) nrows*(testRatio);
    gsl::index ntrain = nrows - ntest;
    std::vector<int> idx(nrows);
    std::iota(idx.begin(), idx.end(), 0);
 
    std::vector<gsl::index> trainIdx, testIdx;
    trainIdx.resize(ntrain);
    testIdx.resize(ntest);
    std::sample(inputIdx.begin(), inputIdx.end(), std::back_inserter(testIdx),
                ntest, std::mt19937{std::random_device{}()});
    std::sort(testIdx.begin(),testIdx.end());
    std::sort(inputIdx.begin(),inputIdx.end());
    std::set_difference(inputIdx.begin(), inputIdx.end(), trainIdx.begin(), trainIdx.end(),
                        std::inserter(testIdx, testIdx.begin()));
    return {trainIdx,testIdx};
}