cmpslib19.h

Go to the documentation of this file.

/*
@cmpslib19.h
@general functions for use by students for homework and labs
*/
#pragma once 

#include <cxxabi.h>
#include <bitset>
#include <time.h>
#include <string>   // string class
#include <string.h> // c-string library
#include <sstream>  // ostringstream
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>  // c file output
#include <stdarg.h>
#include <typeinfo> // find names of ADTs at runtime
#include <limits.h> // min and max values for dataytypes
#include <limits>
#include <ios>
#include <float.h>
#include <math.h>
#include <iomanip>
#include <stdexcept>  // exception handling .. 
#include <signal.h>   // for catching the segfaults
#include <random>
#include <algorithm>  

using std::string;
using std::cout;
using std::cin;
using std::ostringstream;
using std::setfill;
using std::setw;
using std::endl;
using std::boolalpha;



#ifndef DONT_DOCUMENT
template <typename CharT>
std::streamsize ignore_line (std::basic_istream<CharT>& in, bool always_discard = false );
#endif



/**************************************
    user input
 ***************************************/


inline void Prompt (string prompt, string & val)
{
    std::cout  << prompt;
    ignore_line( std::cin );// clear the buffer if needed
    getline(std::cin,  val); // this 
}

    template <class T>
inline void Prompt (string prompt, T & val)
{

    std::cout  << prompt;
    std::cin >> val;
    while(std::cin.fail())  // if it fails... ie user input does not match the datatype
    {
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        std::cout  <<  prompt;
        std::cin >> val;
    }
}


    template <class T>
inline void Prompt( string prompt,T& val, T minval, T maxval)
{
    Prompt(prompt,val);
    while ( val < minval  || val > maxval)
    {
        std::cout  << "The entered value must be with the range " << minval << " to " << maxval << std::endl;
        Prompt(prompt,val);
    }
}





    inline bool PromptYN(string prompt)
    {
        while (true)
        {
            std::cout  << prompt << " (Y/N)"<< std::endl;
            ignore_line( std::cin ); // clear the buffer if needed
            string user_input;
            std::cin >> user_input;
            if ( user_input == "Y" || user_input =="y")
            {
                return true;
            }
            if (user_input == "N" || user_input =="n")
            {
                return false;
            }
        }
    }






    /*********************************************
        system stuff
     *********************************************/

  inline void WaitHundredth(int time)
    {
        struct timespec tim, tim2;
        tim.tv_sec = 0;
        tim.tv_nsec = time*10000000;
        nanosleep(&tim , &tim2);
    }


inline void ClearScreen() {system("clear");}


    inline char * GetTime()
    {
        time_t rawtime = time(0);
        struct tm * timeinfo;

        timeinfo = localtime ( &rawtime );
        return asctime (timeinfo);
    }
    inline string GetDateTime()
    {
        time_t t = time(0);   // get time now
        struct tm * now = localtime( & t );
        ostringstream tm;
        tm << (now->tm_year + 1900) << '-' 
            << setfill('0') << setw(2) <<(now->tm_mon + 1) << '-'
            << setfill('0') << setw(2) << now->tm_mday << "-"
            << setfill('0') << setw(2) << now->tm_hour << ":"
            << setfill('0') << setw(2) << now->tm_min << ":"
            << setfill('0') << setw(2) << now->tm_sec ;
        return tm.str();
    }



    /****************************************
        Numberic fuctions

     *****************************************/

    inline int StringToInteger( string input){return stoi(input);}

    inline double  StringToDouble( string input ){return stod(input);}

  inline string ToLowerCase(string input)
  {
  std::transform(input.begin(), input.end(), input.begin(),
    [](unsigned char c){ return std::tolower(c); });
  return input;
    }

  inline string ToUpperCase(string input)
  {
  std::transform(input.begin(), input.end(), input.begin(),
    [](unsigned char c){ return std::toupper(c); });
  return input;
    }


    inline bool StringToBool(string input)
    {
    input = ToLowerCase(input);
        if(input=="true" || input =="1"){return true;}
        if(input=="false" || input =="0"){return false;}
        return false;
    }



    inline bool VeryClose(float A, float B, float epsilon = 0.0005f)
    {
        return (fabs(A - B) < epsilon);
    }




    template <typename T>
    inline  string NumberToString ( T Number )
        {
            ostringstream ss;
            ss << Number;
            return ss.str();
        }



    inline int CreateRandomNumber(int min, int max)
    {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(min,max);
        return (dis(gen));
    }



    inline bool IsNumber(string str)
    {
        for (unsigned int i = 0; i < str.length(); i++)
            if (! isdigit(str[i])){return false;}
        return true;
    }



    inline bool IsInteger(string input)
    {
        try
        {
            int temp = stoi(input);
            temp++; // to avoid unused var warning
        }
        catch(...){return false;}
        return true;
    }



    inline bool IsDouble(string input)
    {

        try
        {
            double temp = stod(input);
            temp++; // to avoid unused var warning
        }
        catch(...){return false;}
        return true;
    }


    inline string PassFail(int in)
  {
  if ( in > 1) 
  {  
   std::cout << "The PassFail function is designed to take an expresson as its parameter\n something that evaluates to true or false\n you are not using the fuction properly stopping execution of your program. line number " <<__LINE__ << endl;
   exit(9);
  }
  return (in) ? "Pass":"Fail";

  }


  inline string PF(int in) {return PassFail(in);}



template<class T>
inline bool IsSortedAscending(T* data,unsigned int size)
 {
    for(unsigned int loop=0;loop<size-1;loop++)
            if(data[loop]>data[loop+1])
                return false;
    return true;
 }


#ifndef DONT_DOCUMENT
/* this is a kinda cool way to do it, pass in a reference to the array
   unfortunatly it isnt very compatable with most exisitng progams as 
     it implememts some new features to c++ 
   but you dont have to pass in the size as a 2nd parameter        */
template<class T,size_t N>
inline bool IsSortedAscending(T(&data )[N])
 {
    // data is a reference to the array and N is the size of the array
    for(unsigned int loop=0;loop<N -1;loop++)
            if(data[loop]>data[loop+1])
                return false;
    return true;
 }
#endif
  
  
template<class T>
inline bool IsSortedDescending(T* data,unsigned int size)
 {
    for(unsigned int loop=0;loop<size-1;loop++)
            if(data[loop]<data[loop+1])
                return false;
    return true;
 }



#ifndef DONT_DOCUMENT
/* this is a kinda cool way to do it, pass in a reference to the array
   unfortunatly it isnt very compatable with most exisitng progams as 
     it implememts some new features to c++ 
   but you dont have to pass in the size as a 2nd parameter        */
template<class T,size_t N>
inline bool IsSortedDescending(T(&data )[N])
 {
    // data is a reference to the array and N is the size of the array
    for(unsigned int loop=0;loop<N -1;loop++)
            if(data[loop]<data[loop+1])
                return false;
    return true;
 }
#endif
  
  
    /***************************************
        console functions
     ****************************************/


    inline string RED(string input){return string("\033[1;31m"+input+"\033[0m");}
    inline string GREEN(string input){return string("\033[1;32m"+input+"\033[0m");}
    inline string YELLOW(string input){return string("\033[1;33m"+input+"\033[0m");}
    inline string BLUE(string input){return string("\033[1;34m"+input+"\033[0m");}
    inline string MAGENTA(string input){return string("\033[1;35m"+input+"\033[0m");}
    inline string CYAN(string input){return string("\033[1;36m"+input+"\033[0m");}

    inline string ChangeToRed(){return string("\033[1;31m");}
    inline string ChangeToGreen(){return string("\033[1;32m");}
    inline string ChangeToYellow(){return string("\033[1;33m");}
    inline string ChangeToBlue(){return string("\033[1;34m");}
    inline string ChangeToMagenta(){return string("\033[1;35m");}
    inline string ChangeToCyan(){return string("\033[1;36m");}
    inline string ChangeToWhite(){return string("\033[0m");}



inline void PositionCursor(int row,int col){printf("\033[%i;%iH",row+1,col+1);}



template <typename T>
inline std::string GetClassName(const T & a)
{
    int itemp=0;
  char * ptemp = abi::__cxa_demangle( typeid(T).name(),0,0,&itemp);
  std::string temp( ptemp);
  free (ptemp);
  return temp;
}




    /*********************************************************************************************************************
     **********************************************************************************************************************
     below are fucnctions that you wont be calling they are
     for use by other functions
     **********************************************************************************************************************
     **********************************************************************************************************************/
#ifndef DONT_DOCUMENT
    template <typename CharT>
        std::streamsize ignore_line (
                std::basic_istream<CharT>& in, bool always_discard )
        {
            std::streamsize nread = 0;
            if ( always_discard
                    || ( in.rdbuf()->sungetc() != std::char_traits<CharT>::eof()
                        && in.get() != in.widen ( '\n' ) ) )
            {
                // The stream is good, and we haven't
                // read a full line yet, so clear it out
                in.ignore ( std::numeric_limits<std::streamsize>::max(), in.widen ( '\n' ) );
                nread = in.gcount();
            }
            return nread;
        }

#endif