forked from lijiext/lammps
110 lines
4.6 KiB
C++
110 lines
4.6 KiB
C++
#ifndef UTILITY_H
|
|
#define UTILITY_H
|
|
|
|
#include <iostream>
|
|
#include <ctime>
|
|
#undef near
|
|
|
|
using std::vector;
|
|
|
|
namespace Utility
|
|
{
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns true if the value v is between min and max
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline bool InRange(const T &v, const T &min, const T &max)
|
|
{
|
|
return v >= min && v <= max;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns true if the value v is between min and max within the tolerance TOL
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline bool InRange(const T &v, const T &min, const T &max, const T &TOL)
|
|
{
|
|
return InRange(v, min-TOL, max+TOL);
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns the value with the larger absolute value
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline T MaxAbs(const T &a, const T &b)
|
|
{
|
|
return (a*a > b*b) ? a : b;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns the value with the smaller absolute value
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline T MinAbs(const T &a, const T &b)
|
|
{
|
|
return (a*a < b*b) ? a : b;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
// A simple Matlab like timing function
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
inline double tictoc()
|
|
{
|
|
double t_new = clock() / (double) CLOCKS_PER_SEC;
|
|
static double t = t_new;
|
|
double dt = t_new - t;
|
|
t = t_new;
|
|
return dt;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Binary search between low and high for value (assumes array is sorted)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline int SearchSorted(const T* A, T value, unsigned low, unsigned high)
|
|
{
|
|
unsigned mid;
|
|
while ((low+1)<=(high+1))
|
|
{
|
|
mid = (low + high) >> 1; // set mid to mean of high and low
|
|
if (A[mid] > value) high = mid-1; // mid was too high, reduce high
|
|
else if (A[mid] < value) low = mid+1; // mid was too low, increase low
|
|
else return mid;
|
|
}
|
|
return -1; // value not found in array, return -1
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Flat search between low and high for value (assumes array is NOT sorted)
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline int SearchUnsorted(const T* A, T value, unsigned low, unsigned high)
|
|
{
|
|
for (low; low<=high; low++) if (A[low] == value) return low;
|
|
return -1;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Regular swap
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline void Swap(T &a, T &b)
|
|
{
|
|
T temp = a;
|
|
a = b;
|
|
b = temp;
|
|
}
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns the sign of a double precision number
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
inline double Sign(double x) { return (x >= 0.0) ? 1.0 : -1.0; }
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns the sign of a single precision number
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
inline float Sign(float x) { return (x >= 0.0f) ? 1.0f : -1.0f; }
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns the pythagorean distance with the two lengths
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
inline double Norm(double x, double y) { return sqrt(x*x+y*y); }
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Returns square of a value
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
template<typename T>
|
|
inline T Square(T x) { return x*x; }
|
|
}
|
|
|
|
#endif
|