utils.h

Go to the documentation of this file.

 
#include <cstring>
#include <vector>
#include <limits>
#include <vapor/common.h>
 
#pragma once
 
namespace Wasp {
 
class COMMON_API SmartBuf {
public:
    SmartBuf()
    {
        _buf = NULL;
        _buf_sz = 0;
    };
 
    SmartBuf(size_t size)
    {
        _buf = new unsigned char[size];
        _buf_sz = size;
    };
 
    SmartBuf(const SmartBuf &rhs)
    {
        _buf = new unsigned char[rhs._buf_sz];
        _buf_sz = rhs._buf_sz;
        memcpy(_buf, rhs._buf, rhs._buf_sz);
    }
 
    SmartBuf &operator=(const SmartBuf &rhs)
    {
        _buf = new unsigned char[rhs._buf_sz];
        _buf_sz = rhs._buf_sz;
        memcpy(_buf, rhs._buf, rhs._buf_sz);
        return *this;
    }
 
    ~SmartBuf()
    {
        if (_buf) delete[] _buf;
    };
    void * Alloc(size_t size);
    void * GetBuf() const { return (_buf); }
    size_t GetBufSize() const { return (_buf_sz); }
 
private:
    unsigned char *_buf;
    size_t         _buf_sz;
};
 
//
COMMON_API size_t LinearizeCoords(const size_t *coords, const size_t *dims, size_t n);
COMMON_API size_t LinearizeCoords(const std::vector<size_t> &coords, const std::vector<size_t> &dims);
 
COMMON_API size_t LinearizeCoords(const size_t *coords, const size_t *min, const size_t *max, size_t n);
COMMON_API size_t LinearizeCoords(const std::vector<size_t> &coords, const std::vector<size_t> &min, const std::vector<size_t> &max);
 
//
COMMON_API void IncrementCoords(const size_t *min, const size_t *max, size_t *counter, size_t n, int dim);
COMMON_API std::vector<size_t> IncrementCoords(const std::vector<size_t> &min, const std::vector<size_t> &max, std::vector<size_t> counter, int dim = 0);
 
//
COMMON_API std::vector<size_t> Dims(const std::vector<size_t> &min, const std::vector<size_t> &max);
 
COMMON_API size_t VProduct(const size_t *a, size_t n);
COMMON_API size_t VProduct(const std::vector<size_t> &a);
 
COMMON_API void VectorizeCoords(size_t offset, const size_t *min, const size_t *max, size_t *coords, size_t n);
COMMON_API std::vector<size_t> VectorizeCoords(size_t offset, const std::vector<size_t> &min, const std::vector<size_t> &max);
 
COMMON_API void VectorizeCoords(size_t offset, const size_t *dims, size_t *coords, size_t n);
COMMON_API std::vector<size_t> VectorizeCoords(size_t offset, const std::vector<size_t> &dims);
 
//
// blocked submatrix Transpose suitable for multithreading
//   *a : pointer to input matrix
//   *b : pointer to output matrix
//    p1,p2: starting index of submatrix (row,col)
//    m1,m2: size of submatrix (row,col)
//    s1,s2: size of entire matrix (row,col)
//
COMMON_API void Transpose(const float *a, float *b, size_t p1, size_t m1, size_t s1, size_t p2, size_t m2, size_t s2);
 
//
// blocked matrix Transpose single threaded
//   *a : pointer to input matrix
//   *b : pointer to output matrix
//    s1,s2: size of entire matrix (row,col)
//
COMMON_API void Transpose(const float *a, float *b, size_t s1, size_t s2);
 
// Perform a binary search in a sorted (increasing or decreasing) 1D
// vector of values for the
// intervale that contains 'x'. Return the offset 'i' of start of the
// interval containing 'x' in 'sorted'.
//
COMMON_API bool BinarySearchRange(const std::vector<double> &sorted, double x, size_t &i);
 
//
//
COMMON_API bool NearlyEqual(float a, float b, float epsilon = std::numeric_limits<float>::epsilon(), float abs_th = std::numeric_limits<float>::epsilon());
 
};    // namespace Wasp