Code - common functions

From NoskeWiki
Jump to: navigation, search

About

When making large programs, you'll probably notice there are a few basic functions for number, string and vector manipulation which you call again an again. Common function like this might include:

  • finding the average of two numbers .............................. (a "basic function")
  • getting the area of a circle .......................................... (a "geometry function")
  • converting a number (or anything else) to a string ........ (a "string function")
  • replacing certain words in a string with other words ..... (a "string function")
  • generating a random number between two values ........ (a "random number function")
  • getting the current time as a string .............................. (a "time function")
  • eliminating any duplicates in a vector ........................... (a "vector function")
  • saving a string to a file ................................................. (a "file function")
  • ... and any number of other little functions.


The solution I like to use is to create a file called "_common_functions.cpp" where I write all these common functions as (fast) inline methods, so that I can #include this file (#include "_common_function.h") in the top of any other files which may need these methods. No matter what language I used (C++, JavaScript, Java, C#, PHP, etc) I'll tend to create a "common functions" file and over time the number of methods I rely on seems to get longer and longer. Rather than paste all the different language, I've decided to include here just the C++ version.

Disclaimer:

  • Several few of these functions, such as "MIN" and "MAX" and "swapVals", plus some of the constants, already live in the <algorithms> and <limits.h> libraries in C++, however I've still included them here for completeness as they may not live in other languages. Hope some of these functions are of help!
  • Most of these functions were written years ago, and I haven't checked over them all lately to see if they all work... or to improve their efficiency.


Common Functions

Below are the contents of "_common_function.h"

//----------------------------------------------------------------------------
//  _common_functions.h -- Contains several inline functions and templated
//                         functions which I commonly use.
//
//  NOTE: inline template functions have been used instead of macros
//        because, although macros produce simple code
//        (e.g.: "#define SQ(x) ((x)*(x))"), macros are generally less efficient
//        and not recommended in c++ programming.
//
// > author:         Andrew Noske
// > last updated:   4-June-2012
//
//            http://www.andrewnoske.com/wiki/index.php?title=Code_-_common_functions
//----------------------------------------------------------------------------
 
 
#ifndef INC_COMMON_FUNCTIONS_H
#define INC_COMMON_FUNCTIONS_H
 
//############################################################
//## INCLUDES:
 
#include <math.h>       // For some simple maths algorithms.
#include <limits.h>     // For INT_MAX.
#include <stdio.h>      // For file I/O.
#include <vector>       // For use of vectors.
#include <sstream>      // For formatting string output.
#include <iostream>     // For redirecting cout.
#include <string>       // For string.
#include <algorithm>    // For special algorithms (such as sort() and tranform()).
 
using namespace std;
 
//############################################################
 
 
 
//----------------------------------------------------------------------------
//  
//          CONSTANTS:
//  
//----------------------------------------------------------------------------
 
 
//## GEOMETRY RELATED:
 
enum angletype { X, Y, Z, ALL, NONE };
 
const double PI = 3.141592654;
const double RADS_TO_DEGS = 180.0/PI;
const double DEGS_TO_RADS = PI/180.0;
 
 
//## LIMITS:
 
const long MAX_LONG      = (long)2147483647;     // Largest negative value of a long.
const long MIN_LONG      = (long)2147483648;     // Largest positive value of a long.
 
const int MAX_INT      = (int)32767;      // Largest negative value of a (singed) int.
const int MIN_INT      = (int)32768;      // Largest positive value of a (signed) int.
 
const double DOUBL_MAX  = (double) 1.7976931348623158e+308;     // Largest pos double.
const double DOUBL_MIN  = (double)-1.7976931348623158e+308;     // Largest neg double.
 
const float FLOAT_MAX      = (float) 3.40282e38;       // Largest positive value float.
const float FLOAT_MIN_POS  = (float) 1.17549e-38;      // Smallest positive value float.
const float FLOAT_MIN      = (float)-3.4027e35;        // Largest negative value float.
 
 
//----------------------------------------------------------------------------
//  
//          FUNCTION DECLARATION:
//  
//----------------------------------------------------------------------------
 
 
//## BASIC FUNCTIONS:
 
template <typename type>  type SQ(type x);
template <typename type>  type CUBE(type x);
template <typename type>  type MIN(type val1, type val2);
template <typename type>  type MAX(type val1, type val2);
template <typename type>  void updateMax(type &max, type newVal);
template <typename type>  void updateMin(type &min, type newVal);
template <typename type>  type ABS(type val);
template <typename type>  void swapVals(type &val1, type &val2);
template <typename type>  void swapValsAsc(type &val1, type &val2);
template <typename type>  void keepWithinRange(type &val, type min, type max);
template <typename type>  bool isBetween(type limit1, type val, type limit2);
template <typename type>  bool isBetweenAsc(type min, type middle, type max);
template <typename type>  bool isBetweenNI(type limit1, type val, type limit2);
 
inline float fMod(float val, float modVal);
inline int intMod(int val, int modVal);
inline float fModWithinRange(float val, float min, float max);
inline void changeIntWithinRange(int &val, int min, int max, int increment);
inline void cycleIntWithinRange(int &val, int min, int max, int increment);
template <typename type>  void changeNumWithinRange(type &val, type min, type max, type changeAmount);
inline float fDiv(float numerator, float denominator);
inline float fDivCustom(float numerator, float denominator, float infinityValue=FLOAT_MAX);
inline bool isFactor(float value, float divisor);
inline int roundToInt(float x);
inline float roundPrec(float value, float precision);
inline float roundDecimal(float value, int decimal);
inline float avg(float val1, float val2);
inline float getFractBetween(float val1, float val2, float fractTowards2);
inline float calcPercent(float numerator, float denominator);
inline int calcPercentInt(float numerator, float denominator);
inline int calcPercentFloor(float numerator, float denominator);
 
//## GEOMETRY FUNCTIONS:
 
inline void keepAngleInRange(float &angle);
inline float geom_volumeSphere(const float radius);
inline float geom_surfaceAreaSphere(const float radius);
inline float geom_volumeConicalFrustrum(const float rBase, const float rTop, const float height);
inline float geom_surfaceAreaConicalFrustrum(const float rBase, const float rTop, const float height);
inline float geom_areaCircle(const float radius);
 
 
//## STRING FUNCTIONS:
 
template <typename type>  string toString(type value);
template <typename data>  string toStringPadNumber(data value, int padLength, char padChar='0');
template <typename data>  string toStringWithCommas(data value);
 
inline string toString(float value, int decimal);
inline float string_getFloatFromString(string str);
 
inline string string_substr (string str, int chars, int offset);
inline string string_substrFromEnd (string str, int charsAtEnd);
inline bool string_startsWith (const string haystack, const string needle);
 
inline string string_replace (string str, const string searchStr, const string replaceStr);
inline string string_eliminateDuplicates(const string haystack, const string needle);
inline vector<string> string_explode(string str, string explodeStr);
inline string string_explodeGetArgument(string str, string sepStr, int argNum, bool eliminateDuplicates=true);
 
 
//## RANDOM NUMBER FUNCTIONS:
 
inline void seedRandom();
inline double highResRand();
inline double randCoef();
inline double randCoefOneNotInclusive();
inline double randHighResCoef();
inline double randHighResCoefOneNotInclusive();
inline double randDbl(double min, double max);
inline int randIntInclusive(int min, int max);
inline float randFlt(float min, float max);
 
//## TIME FUNCTIONS:
 
inline string time_getCurrTimeStampString();
inline string time_getCurrTimeStampStringWithUnderscores();
inline long time_getCurrTimeInSecs();
inline string time_formatTimeElapsed(long secsElapsed, bool includeSecs, bool simpleFormat);
 
 
//## VECTOR FUNCTIONS:
 
template <typename type>  bool vector2D_transpose(vector< vector<type> > &v);
template <typename type>  void vector_eliminateDuplicates(vector<type> &v);
template <typename type>  bool vector_doesElementExistInVector(vector<type> v, type element);
template <typename type>  vector<type> vector_concat(vector<type> &v1, vector<type> &v2);
template <typename type>  vector<type> vector_sort(vector<type> v, int startIdx, int endIdx=INT_MAX);
template <typename type>  vector<type> vector_sort(vector<type> v);
template <typename type>  vector<type> vector_reverse(vector<type> v, int startIdx=0, int endIdx=INT_MAX);
 
 
//## FILE FUNCTIONS:
 
inline bool file_saveStringToFile(string filePath, string text, bool append);
inline vector<string> file_loadTextFromFile(string filePath, bool printStatus=true);
 
 
 
//----------------------------------------------------------------------------
//  
//          FUNCTION DEFINITIONS:
//  
//----------------------------------------------------------------------------
 
 
 
 
//----------------------------------------------------------------------------
//## BASIC FUNCTIONS
//----------------------------------------------------------------------------
 
 
//----------------
//-- Returns the given number squared
template <typename type>
inline type SQ(type x)    { return (x*x);  }
//----------------
//-- Returns the given number cubed
template <typename type>
inline type CUBE(type x)    { return (x*x*x); }
 
//----------------
//-- Returns the smaller of the two values fed in (NOTE: this
//-- function already exists, but use capitals to avoid ambiguity)
template <typename type>
inline type MIN(type val1, type val2)
{ return (val1 < val2) ? val1 : val2; }
//----------------
//-- Returns the greater of the two values fed in (NOTE: this
//-- function already exists, but use capitals to avoid ambiguity)
template <typename type>
inline type MAX(type val1, type val2)  
{ return (val1 > val2) ? val1 : val2; }
 
//----------------
//-- Updates max is newVal is greater than max
template <typename type>
inline void updateMax(type &max, type newVal)
{ if(max < newVal)  max = newVal; }
//----------------
//-- Updates min is newVal is less than than min
template <typename type>
inline void updateMin(type &min, type newVal)
{ if(min > newVal)  min = newVal; }
 
//----------------
//-- Used to avoid shitty error message g++ was giving me "error:
//-- call of overloaded 'abs(float)' is ambiguous"
template <typename type>
inline type ABS(type val)
{ return (val >= 0) ? val : -val; }
 
//----------------
//-- Will swap the two values around
//-- (i.e. the value in "val2" will end up in val1 and vice-versa)
template <typename type>
inline void swapVals(type &val1, type &val2) {
  type tempVal = val1;
  val1 = val2;
  val2 = tempVal;
}
 
//----------------
//-- Will (if necessary) swap the values around such
//-- that val1 <= val2 will be true
template <typename type>
inline void swapValsAsc(type &val1, type &val2) {
  if(val1 > val2) {
    type tempVal = val1;
    val1 = val2;
    val2 = tempVal;
  }
}
 
//----------------
//-- Will change val to min or max (whichever is closer)
//-- if it is outside of these two value.
template <typename type>
inline void keepWithinRange(type &val, type min, type max) {
  if(val < min)    val = min;
  if(val > max)    val = max;
}
 
//----------------
//-- Determines if val is between the two limit values, whereby
//-- the limit values are not necessarily in the order lowest, highest.
template <typename type>
inline bool isBetween(type limit1, type val, type limit2) {    
  return ((limit1 <= val && val <= limit2) || (limit2 <= val && val <= limit1));
}
//----------------
//-- Determines if val is between the two limit values (min & max) inclusive.
template <typename type>
inline bool isBetweenAsc(type min, type middle, type max) {
  return (min <= middle && middle <= max);
}
//----------------
//-- Determines if val is between the two limit values NOT INCLUSIVE, whereby
//-- the limit values are not necessarily in the order lowest, highest.
template <typename type>
inline bool isBetweenNI(type limit1, type val, type limit2) {    
  return ((limit1 < val && val < limit2) || (limit2 < val && val < limit1));
}
 
//----------------
//-- Returns (positive) remainder between 0 and modVal (modVal not
//-- inclusive) after dividing value by modVal. Is equivalent to
//-- fmod(d1,d2), but seems to be faster.
inline float fMod(float val, float modVal) {
  if(val >= modVal) {
    int divisor = int(val / modVal);
    return (val - divisor*modVal);
  }
  else if(val < 0) {
    int divisor = (int)ceil(-val / modVal);    //rounds up
    return (val + divisor*modVal);
  }
  return (val);
}
 
//----------------
//-- Returns (positive) remainder between 0 and modVal-1. Unlike normal
//-- mod (%) this can handle negative numbers.
inline int intMod(int val, int modVal) {
  if(modVal == 0) {
    return (0);
  }
  else if(val >= modVal) {
    return (val % modVal);
  }
  else if(val < 0) {
    int divisor = (int)ceil(float(-val) / float(modVal));    // Rounds up
    return (val + divisor*modVal);
  }
  return (val);
}
 
 
//----------------
//-- If values is outside min or max, it wraps it around so
//-- it is between the values using fMod
//-- EG: fModWithinRange (270, -180, 180) -> -90
//-- EG: fModWithinRange (4,   5,    10) -> 9
inline float fModWithinRange(float val, float min, float max) {
  if(val >= min && val < max) {
    return (val);
  }
  else {
    return (fMod(val-min, max-min) + min);
  }
}
 
//----------------
//-- Changes "val" by "increment", but prevents it from becoming any
//-- less than "min" or greater than "max".
inline void changeIntWithinRange(int &val, int min, int max,
                                  int increment)
{
  val = val + increment;
  if(val < min)    val = min;
  if(val > max)    val = max;
}
 
//----------------
//-- Changes/cycles "val" by "increment", while wrapping it around
//-- the edges so that it stays always remains between min and max.
inline void cycleIntWithinRange(int &val, int min, int max,
                                 int increment)
{
  val = val + increment;
  val = intMod(val-min, max-min) + min;
}
 
//----------------
//-- Changes "val" by "increment", but prevents it from becoming
//-- any less than "min" or greater than "max".
 
template <typename type>
inline void changeNumWithinRange(type &val, type min, type max,
                                  type changeAmount)
{
  val = val + changeAmount;
  if(val < min)    val = min;
  if(val > max)    val = max;
}
 
 
//----------------
//-- Used to avoid divide by 0 error
inline float fDiv(float numerator, float denominator)
{
  if(denominator == 0)
    return FLOAT_MAX;
  return numerator/denominator;
}
 
//----------------
//-- Used to avoid divide by 0 error
inline float fDivCustom(float numerator, float denominator,
                             float infinityValue)
{
  if(denominator == 0)
    return infinityValue;
  return numerator/denominator;
}
 
//----------------
//-- Returns true if the given value is evenly divisible by the given divosor
 
inline bool isFactor(float value, float divisor)
{
  float result = value / divisor;
  return (result == (float)(floor(result)));
}
 
//----------------
//-- Rounds float to the nearest integer
inline int roundToInt(float x)
{
  return int((x > 0.0) ? (x + 0.5) : (x - 0.5));
}
 
//----------------
//-- Founds float to nearest multiple of "precision"
inline float roundPrec(float value, float precision)
{
  if(precision == 0)
    return (value);
  return (float)(roundToInt(value / precision) * precision);
}
 
//----------------
//-- Founds float to nearest multiple of "precision"
inline float roundDecimals(float value, int decimals)
{
  float precision = pow(0.1f, (float)decimals);
  return (float)(roundToInt(value / precision) * precision);
}
 
//----------------
//-- Averages two numbers.
inline float avg(float val1, float val2)
{
  return (val1 + val2) / 2.0;
}
 
//----------------
//-- Finds the value "fractTowards2" along the way from val1 towards val2.
 
inline float getFractBetween(float val1, float val2,
                               float fractTowards2)
{
  return (((val2 - val1) * fractTowards2) + val1);
}
 
 
//----------------
//-- Returns "numerator"/"denominator" as a percentage.
 
inline float calcPercent (float numerator, float denominator)
{
  if(denominator==0)
    return 100.0f;
  float percent = (numerator / denominator) * 100.0f;
  return percent;
}
 
//----------------
//-- Returns "numerator"/"denominator" as a percentage rounded to the nearest integer.
 
inline int calcPercentInt(float numerator, float denominator)
{
  if(denominator==0)
    return 100;
  float percent = (numerator / denominator) * 100.0f;
  return roundToInt(percent);
}
 
//----------------
//-- Returns "numerator"/"denominator" as a percentage rounded down to an integer. 
 
inline int calcPercentFloor(float numerator, float denominator)
{
  if(denominator==0)
    return 100;
  float percent = (numerator / denominator) * 100.0f;
  return floor(percent);
}
 
 
 
 
 
//----------------------------------------------------------------------------
//## GEOMETRY FUNCTIONS:
//----------------------------------------------------------------------------
 
//----------------
//-- Keeps angle value between 0 and 360 (useful for functions like atan
//-- which may return a negative angle)
inline void keepAngleInRange(float &angle)    
{ angle = (float)fMod(angle, 360); }
 
//----------------
//-- Calculates the volume of a sphere with given radius     {4/3 PI r^3}
inline float geom_volumeSphere(const float radius)
{ return (4.0/3.0 * PI * (radius*radius*radius)); }
 
//----------------
//-- Calculates the surface area of a sphere with given radius   {4 PI r^2}
inline float geom_surfaceAreaSphere(const float radius)
{ return (4.0 * PI * (radius*radius)); }
 
 
//----------------
//-- Calculates the volume of conical frustrum (a cylinder with different
//--  radius at either end)  { 1/3*PI*h*(R^2*Rr*r^2) }
inline float geom_volumeConicalFrustrum(const float rBase, const float
                                         rTop, const float height)
{ return (1.0/3.0 * PI * height * (SQ(rBase) + (rBase*rTop) + SQ(rTop))); }
 
 
//----------------
//-- Calculates the surface area of conical frustrum (a cylinder with
//-- different radius at either end)
//-- NOT including the areas of the circle at the base and at the top
inline float geom_surfaceAreaConicalFrustrum(const float rBase, const
                                              float rTop, const float height)
{ return (  PI * (rBase+rTop) * sqrt(SQ((rBase-rTop)) + SQ(height))  ); }
 
//----------------
//-- Calculates the area of a circle given its radius     {PI r^2}
inline float geom_areaCircle(const float radius)
{ return (PI * (radius*radius)); }
 
 
 
 
//----------------------------------------------------------------------------
//##                  STRING FUNCTIONS:
//----------------------------------------------------------------------------
 
 
//-------------
//-- Takes a single value of *almost* any type and returns it as a string
//-- by using ostringstream (string output stream).
//-- This function will also work for your own classes/structures, but only
//-- if you specify a "<<" operator.
//--
//-- FOR EXAMPLE: "friend ostream& operator<< (ostream &os, myPoint p)
//-- {os << pd.x << ',' << pd.y; return os;}"
 
template <typename type>
inline string toString(type value)
{
  ostringstream out;
  out << value;
  return out.str();
}
 
//-------------
//-- Takes a number and converts to a string, but if it
//-- is < padLength digits long, then it will add extra characters
//-- ("0"'s by default) on the left of it if.
//-- 
//-- EXAMPLE: (value=5, padLength=4, padChar='0') ->  return "0005"
 
template <typename data>
inline string toStringPadNumber(data value, int padLength, char padChar)
{  
  string returnStr = toString(value);
  while((int)returnStr.length() < padLength)
    returnStr = padChar + returnStr;
  return returnStr;
}
 
//-------------
//-- Takes a number and adds commas (eg: 10000.05 -> 10,000.05)
 
template <typename data>
inline string toStringWithCommas(data value)
{
  string str = toString(value);
  int digitsBeforeDec = toString((int)value).length();
 
  if(digitsBeforeDec <= 3)
    return str;
 
  int numCommasNeeded = ((digitsBeforeDec-1) / 3);
  int leadingDigits   = digitsBeforeDec - numCommasNeeded*3;
 
  string returnStr = string_substr(str, leadingDigits, 0);
  for(int i=0; i<numCommasNeeded; i++)
    returnStr = returnStr + "," + string_substr(str, 3, leadingDigits+i*3);
 
  return returnStr;
}
 
 
//-------------
//-- Takes a float and converts it to a string but limits the decimal places
 
inline string toString(float value, int decimal)
{  
  float exponent = (float)pow((float)10, (float)decimal);
  float newValue = ((int)(value * exponent))/exponent ;
  return toString(newValue);
}
 
//-------------
//-- Takes a string an returns a float by calling "atof" - which can
//-- handle the chars: '-', '.' and 'e' - eg: "-5.3e4" -> 53000).
//-- If there are bad characters 0 will be returned (maybe an error
//-- message should appear instead).
 
inline float string_getFloatFromString(string str) {
  return (atof(str.c_str()));
}
 
//-------------
//-- Gets a substring (safely), from the start of a string.
 
inline string string_substr (string str, int chars, int offset)
{
  if(offset >= (int)str.length() || offset < 0)
    offset = (int)str.length();
  if(chars + offset >= (int)str.length())
    chars = (int)str.length() - offset;
  return str.substr(offset, chars);
}
 
 
//-------------
//-- Gets a substring (safely), from the end of the string.
//-- EXAMPLE: ("myfile.jpg",3) -> "jpg"
 
inline string string_substrFromEnd (string str, int charsAtEnd)
{
  if(charsAtEnd >= (int)str.length())
    return str;
  return str.substr((int)str.length()-charsAtEnd, charsAtEnd);
}
 
//-------------
//-- Returns true if the given haystack string STARTS with needle string.
//-- EXAMPLE: ("string", "str") -> true
 
inline bool string_startsWith (const string haystack, const string needle)
{
  if(needle.length() > haystack.length())
    return false;
  for(int i=0; i<(int)needle.length(); i++)
    if(haystack[i]!=needle[i])
      return false;
  return true;
}
 
 
//-------------
//-- Searches the string "str" Replaces ALL occurances of "searchStr" and replaces them with "replaceStr"
//-- EXAMPLE: ("now or forever", "or", "|") -> "now | f|ever"
 
inline string string_replace (string str, const string searchStr, const string replaceStr)
{
  if(searchStr == replaceStr || str == "" || searchStr == "")
    return str;
 
  string::size_type pos = 0;
  while((pos = str.find(searchStr, pos)) != string::npos)
    str.replace(pos, searchStr.size(), replaceStr);
 
  return str;
}
 
 
 
//-------------
//-- Eliminates ALL immediate repeats of the same needle string inside the haystack string.
//-- 
//-- EXAMPLE: ("Spaces  are    bad", " " ) -> "Spaces are bad"
//-- EXAMPLE: ("I am am am bad",     "am ") -> "I am bad"
 
inline string string_eliminateDuplicates(const string haystack, const string needle) {
  return string_replace(haystack, needle+needle, needle);
}
 
//-------------
//-- Takes a string and splits it apart anywhere the explodeStr appears (not inclusive), thus forming a vector of smaller strings.
//--
//-- eg: input: ("one|two|three", "|") -> returns: vector("one", "two", "three")
 
inline vector<string> string_explode(string str, string explodeStr) {
  vector<string> ret;
  int iPos = (int)str.find(explodeStr, 0);
  int iPit = (int)explodeStr.length();
  while(iPos > -1) {
    if(iPos!=0)
      ret.push_back(str.substr(0,iPos));
    str.erase(0,iPos+iPit);
    iPos = (int)str.find(explodeStr, 0);
  }
  if(str!="")
    ret.push_back(str);
  return ret;
}
 
//-------------
//-- Calls string_explode and returns the specified argument (element) in the vector.
//-- If there are less than argNum elements an empty string is returned.
//-- NOTE: If eliminateDuplicates is true then any empty "arguments" are removed before chosing.
//-- 
//-- EXAMPLE: ("one/two/three", "/", 2, false) -> returns "two"
 
inline string string_explodeGetArgument(string str, string sepStr, int argNum,
                                         bool eliminateDuplicates)
{
  if(eliminateDuplicates)
    str = string_eliminateDuplicates(str, sepStr);
 
  vector<string> strVec = string_explode(str, sepStr);
 
  return (argNum>(int)strVec.size()) ? ("") : (strVec.at(argNum-1));
}
 
 
 
 
//--------------------------------------------------------------------------------------------------
//## RANDOM NUMBER FUNCTIONS:
//--------------------------------------------------------------------------------------------------
 
 
//----------------
//-- The following functions return random coefficients, but differ in resulotion
//-- and wether or not 1 is inclusive.
//--
//-- NOTE: RAND_MAX = 32767. This isn't enough granularity for all purposes, in which case one
//--       of the two "high res" functions should be used. These provide a granulatiry of approx
//--       1E9 (1 billion possible coefficient values).
//-- 
//-- WARNING:  Before calling these, make sure the rand function is seeded by
//--           calling srand(time(0));
 
#include <time.h>    // for time_t and clock_t;
 
const double RAND_MAX_D          = double(RAND_MAX);                   // The largest value generated by rand() as a double.
const double RAND_MAX_HIGH_RES_D = RAND_MAX_D*RAND_MAX_D + RAND_MAX_D; // The largest value generated by highResRand() as a double.
 
 
inline void seedRandom() {              //-- Seeds all future generation of random numbers using rand().
  srand((int)time(0));
}
inline double highResRand() {              //-- Returns a high resolution random value between 0 and 1,073,709,056 as a double.
  return ((double(rand())*double(RAND_MAX)) + double(rand()));
}
inline double randCoef() {              //-- Returns a low resolution random coefficients: 0<=value<=1.
  return  rand() /RAND_MAX_D;
}
inline double randCoefOneNotInclusive() {      //-- Returns a low resolution random coefficients: 0<=value<1.
  return  rand() / (RAND_MAX_D+0.1);
}
inline double randHighResCoef() {          //-- Returns a high resolution random coefficients: 0<=value<=1.
  return  highResRand() / RAND_MAX_HIGH_RES_D;
}
inline double randHighResCoefOneNotInclusive() {  //-- Returns a high resolution random coefficients: 0<=value<1.
  return  highResRand() / (RAND_MAX_HIGH_RES_D + 1.0);
}
inline double randDbl(double min, double max) {    //-- Returns a high resolution random double between min and max .
  return double(min + (randHighResCoef() * (max - min)));    // (NOTE: if max is 2, then it won't return a value higher than 2).
}
inline int randIntInclusive(int min, int max) {    //-- Returns a high resolution random integer between min and max inclusive.
  return int((randHighResCoefOneNotInclusive() * double(max-min+1)) + double(min));
}
inline float randFlt(float min, float max) {    //-- Returns a low resolution random float between min and max. 
  return float(min + ((rand()/RAND_MAX_D) * (max - min)));   // (NOTE: if max is 2, then it won't return a value higher than 2).
}
 
 
//--------------------------------------------------------------------------------------------------
//##          TIME FUNCTIONS:
//--------------------------------------------------------------------------------------------------
 
 
 
#include <time.h>    // for time_t and clock_t;
 
 
//-------------
//-- Returns a string for a timestamp value in the form: "06/24/04 14:10:40" (which can be interpreted by excel)
inline string time_getCurrTimeStampString()  
{
  char timestamp[30];
  time_t currTime = time(0);
  strftime(timestamp,30,"%x %X",localtime(&currTime));  // Get timeStamp (eg: "06/24/04 14:10:40").
  return timestamp;
}
 
//-------------
//-- Returns a string for a timestamp value in the form: "Thu_06/24/04_14:10:40"
inline string time_getCurrTimeStampStringWithUnderscores()  
{
  char timestamp[30];
  time_t currTime = time(0);
  strftime(timestamp,30,"%a_%x_%X",localtime(&currTime));      // Get timeStamp (eg: "Thu_06/24/04_14:10:40").
  return timestamp;
}
 
//-------------
//-- Returns the current time in seconds, as a long
inline long time_getCurrTimeInSecs()
{
  time_t currTime = time(0);
  return long(currTime);
}
 
//-------------
//-- Takes the numbers of seconds elapsed and formats a string in the form: "1 hrs 9 mins 23 secs" or "1:09 s" if simpleFormat is true
 
inline string time_formatTimeElapsed(long secsElapsed, bool includeSecs, bool simpleFormat)
{
  int hours      = int(secsElapsed / 3600);
  secsElapsed    = secsElapsed - (hours*3600);
  int minutes    = int(secsElapsed / 60);
  int seconds    = secsElapsed - (minutes*60);
 
  string formatted = ((hours) ? toString(hours) + " hrs " : "") + toString(minutes) + " mins " + ((includeSecs) ? toString(seconds) + " secs" : "");
 
  if(simpleFormat)
    formatted = toString(hours) + ":" + toStringPadNumber(minutes, 2);
 
  return(formatted);
}
 
 
 
 
//----------------------------------------------------------------------------
//##          VECTOR RELATED FUNCTIONS:
//----------------------------------------------------------------------------
 
 
//-------------
//-- Takes a two dimensional vector and reverses the order of the dimensions.
//-- for example:
//---               { {0,1,2},
//--                  {3,4,5} }
//-- would become:  
//--                { {0,3},
//--                  {1,4},
//--                  {2,5} }
//--
//-- NOTE: If any of the second dimension are DIFFERENT lengths,
//-- then returns false.
 
template <typename type>
bool vector2D_transpose(vector< vector<type> > &v)
{
  if(v.empty() || v[0].empty())
    return false;
 
  int DIM_X = (int)v.size();
  int DIM_Y = (int)v[0].size();
 
  //## CHECK ALL VECTORS (IN THE MAIN VECTOR) ARE SAME SIZE:
  for(int x=1; x<DIM_X; x++)
    if(v[x-1].size() != v[x].size())
      return false;
 
  //## CREATE TRANSPOSED VERSION:
  vector< vector<type> > vT;
  vT.resize(DIM_Y);
  for(int x=0; x<DIM_Y; x++)
    vT[x].resize(DIM_X);
 
  for(int x=0; x<DIM_X; x++)
    for(int y=0; y<DIM_Y; y++)
      vT[y][x] = v[x][y];
 
  v = vT;
 
  return true;
}
 
//-------------
//-- Eliminates duplicates from a vector, but ONLY if they
//-- occur sequentially - hence user should sort the vector first.
//--
//-- EXAMPLE 1: {1,3,3,3,5} -> the second two 3's will be removed
//-- EXAMPLE 1: {3,1,3,5,3} -> no elements will be removed  :(
 
template <typename type>
void vector_eliminateDuplicates(vector<type> &v)
{
    for(int i=1; i<(int)v.size(); i++)
    if(v[i-1]==v[i])
    {
      v.erase(v.begin()+i);
      --i;
    }
}
 
//-------------
//-- Checks if element already exists
 
template <typename type>
inline bool vector_doesElementExistInVector(vector<type> v, type element)
{
    for(int i=0; i<(int)v.size(); i++)
    if(element == v.at(i)) {
      return (true);
    }
 
  return (false);
}
 
//-------------
//-- Appends the contents of the second vector to the end of
//-- the first vector and returns the result
 
template <typename type>
vector<type> vector_concat(vector<type> &v1, vector<type> &v2)
{
  vector<type> returnVec = v1;
 
  for(int i=0; i<(int)v2.size(); i++)
    returnVec.push_back(v2[i]);
 
  return returnVec;
}
 
//-------------
//-- Sorts given vector in ascending order, starting with
//-- the elment at the index startIdx
 
template <typename type>
inline vector<type> vector_sort(vector<type> v, int startIdx, int endIdx)
{
  if(startIdx < 0)
    startIdx = 0;
  if(endIdx > (int)v.size()-1)
    endIdx = (int)v.size()-1;
 
#if defined (__APPLE__)
        // NOTE: For some reason the "sort()" command doesn't work on OSX, so
        //       I've had to write my own heap sort (RECENTLY MODIFIED SO NOT CHECKED)
 
  int n;                  // Current last element on heap.
  for(n=startIdx; n<=endIdx; n++)  //## Build heap by doing a "siftup" on each new element:
  {
    int i=n;       // The newest element added to heap.
    int p=(n-startIdx)/2;     // its parent
    for(; p>=0 && v[i] > v[p]; i=p, p=(i-startIdx)/2)    // While bigger than parent: swap.
      swap(v[i], v[p]);
  }
  for(n=endIdx; n>=startIdx;)    //## Deconstruct heap by moving max element to the end and doing a "siftdown":
  {
    swap(v[startIdx], v[n--]);  // Move max element to the end.
    int i = startIdx;             // Current element to "siftdown".
    int c = i+1;                  // First child of current element.
    for(; c<=endIdx; i=c, c=(c-startIdx)*2)
    {
      if(c+1<=endIdx && v[c+1] > v[c])  // If other child is bigger: use this child.
        c++;
      if(v[i] >= v[c] )                 // If node is bigger than parent: stop.
        break;
      swap(v[c], v[i]);                 // Else swap with child and continue.
    }
  }
  return v;
 
#else
 
  sort(v.begin()+startIdx, v.begin()+endIdx);
  return v;
 
#endif
 
}
 
//-------------
//-- Sorts given vector in ascending order (from first to last element)
 
template <typename type>
vector<type> vector_sort(vector<type> v)
{
#if defined (__APPLE__)
 
  return vector_sort(v, 0);
 
#else
 
  vector<type> returnVec = v;
  sort(returnVec.begin(), returnVec.end());
  return returnVec;
 
#endif
 
}
 
//-------------
//-- Reverses the order of elements from "startIdx" to "endIdx" inclusive
 
template <typename type>
inline vector<type> vector_reverse(vector<type> v, int startIdx, int endIdx)
{
  if(startIdx < 0)
    startIdx = 0;
  if(endIdx > (int)v.size()-1)
    endIdx = (int)v.size()-1;
 
  vector<type> returnVec;
 
  for(int i=0; i<startIdx; i++)
    returnVec.push_back(v[i]);
  for(int i=startIdx; i<=endIdx; i++)
    returnVec.push_back(v[endIdx-(i-startIdx)]);
  for(int i=endIdx+1; i<(int)v.size(); i++)
    returnVec.push_back(v[i]);
 
  return returnVec;  
}
 
 
 
 
//----------------------------------------------------------------------------
//##          VECTOR RELATED FUNCTIONS:
//----------------------------------------------------------------------------
 
//-------------
//-- Loads all lines of text from the text file into a vector of strings.
 
inline vector<string> file_loadTextFromFile(string filePath, bool printStatus)
{
  const int MAXLINEFORREADING = 2048;
 
  vector<string> text;
  char line[MAXLINEFORREADING];
 
  //## OPEN TEXT FILE FOR INPUT:
 
  if(printStatus)
    cout << "Opening file '" << filePath << "'" << endl;
 
  FILE *fp = fopen(filePath.c_str(), "r");
 
  if(fp == NULL)
  {
    if(printStatus)
      cout << "ERROR: Opening of file '" << filePath << "' failed." << endl;
    return text;
  }
 
  while (fgets(line, MAXLINEFORREADING, fp) != NULL)
    text.push_back(line);
 
  if(fp != NULL)
    fclose(fp);
 
  return text;
}
 
//-------------
//-- Saves a string to the file, and returns true if successful
 
inline bool file_saveStringToFile(string filePath, string text, bool append=false)
{
  //## OPEN TEXT FILE FOR WRITING:
 
  FILE *fp = (append) ? fopen(filePath.c_str(), "a") : fopen(filePath.c_str(), "w");
 
  if(fp == NULL)
  {
    cout << "ERROR: Opening of file '" << filePath << "' failed." << endl;
    return false;
  }
 
  fputs(text.c_str(), fp);
 
  if(fp != NULL)
    fclose(fp);
 
  return true;
}
 
//----------------------------------------------------------------------------
#endif


Links: