Rüdiger Utilities (libruti)

This is my personal collection of utitlity function which I am bored of to code ever and ever again. In particular this collection contains some functions I consider so fundamental (like strtrim) that I still puzzled that they are not included in the glibc.

I publish them under the LPGL to everybody. I you have an issue with this license, please contact me. I am pretty sure we will find an approriate alternative way of licensiong

libruti in detail

• String functions
• File operations
• Mathematical Functions
• Dynamic Memory Allocation
• Measuring Runtime
• Parameter file parser
• Vector class (3dim-Vector)
• Variable sized math type Vector class
• Variable sized math type Matrix class
• Simple Thread Scheduling class

String functions

• bool isWS(const char c)
  Tests if c is a whitespace.
• bool isSeparator(char t, char sep, bool ws)
  Tests if c is a whitespace if ws is true.
  Tests if c is a identical to sep if ws is false. This function is used by split().
• char * strtrim(char *str)
  Cut all whitespace from the end of str and returns the pointer to the first char in str that is not a whitespace
• const char *nextWS(const char * str)
  Returns the pointer to the next white space charater in str or the pointer to the end of the string. If str already points to a white space str itself is returned.
• const char *nextNonWS(const char * str)
  Returns the pointer to the next charater in str that is not a white space or the pointer to the end of the string. If str already points to a character that is not a white space than str itself is returned.
• const char *nextArg(const char * str)
  Consequtive application of nextWS() and nextNonWS(). That means if str points to one argument in an white space separated list (like with command line arguments) the return value of the function points to the next one. If nothing is left in str a pointer to '\0' is returned.
• int split(char *txt,char **elem ,int max, char sep, bool ws)
  This function cuts the string txt into (at most) max segments. The segements can be acced using the elem[] array. The segment are cut at whitespaces (ws=true) or at sep(ws=false).
  The elem[] must be an array with at least max allocated. split() does not allocate any memory.
  Please note that the string txt is modified by split().
• int split(char *txt,char **elem ,int max, char sep)
  This is just a call to split() (see above) with ws=false. Basically this version cuts at sep.
• int split(char *txt,char **elem ,int max)
  This is just a call to split() (see above) with ws=true and sep neglected. Basically this version cuts at whitespaces.
• char *toUpper(const char *src)
  Returns a copy of src with all alpha-characters turned to upper case.
• char *toLower(const char *src)
  Returns a copy of src with all alpha-characters turned to lower case.
• char * allocStrCpy(const char *src)
  Returns a pointer to a char array (string) which points to a copy of src.

File operations

• bool fileExists(const char *file);
  Test if the file file exists.
• bool isDirectory(const char *path);
  Test if the file path exists and if it is a directory.
• bool mkdirTree(const char *path);
  Creates the directory path and all its parents as required.
• bool copyFile(const char *src, const char *dest);
  Copies the contents of the file src to another file nameddest.
• int logprintf(FILE *fp, const char *format, ...);
  This is a combination of normal printf and fprintf. The output is printed both to the file given by FILE *fp and to stdout. This is useful to print diagnostic messages both to a log file and stdout.
• class RutiFiles
  This class creates filenames and files according to the follwoing names scheme:
  Each name consists of three parts:
  1. A base path
  2. A base name
  3. A individual name and extension

  For all files create by one instances of RutiFiles the components base path and base name are the same. Only the third individual part differs. However, this might be more than just different extension.

  The rational behind this class is the following. If one has a program which creates a couple of files (log files, data files, result files etc.) all files belonging to one run shall be named similar differing only by a part indicating its diffenrent contents. Thie can be achieved with this class. Different runs shall have at least different base names but with in a run the file names differ only by the individual part.

  • RutiFiles(const char *p, const char *n)
    This constructor creates an instance of RutiFiles with empty base path and base name.
  • RutiFiles(const char *p, const char *n)
    This constructor creates an instance of RutiFiles with base path and base name given byp and n, respectively.
  • void init(const char *p, const char *n)
    This methods sets the base path and base name to p and n, respectively. Useful if the instance was created by the simple constructor.
  • FILE * open(const char *file, const char *mode)
    Open a file with file as the individual part of the file name and in mode mode.
  • const char * name(const char *file)
    Returns a file name with file as the individual part of the file name.

Mathematical Functions

• int powi(int b, int e);
  Take the integer b to the power of e. The value of e must be greater zero.
• float powi(float b, int e);
  Take the float b to the power of e. The value of e must be greater zero.
• double powi(double b, int e);
  Take the double b to the power of e. The value of e must be greater zero.

Dynamic Memory Allocation

• tempate <class TYPE> class ArrayAllocator
  

  The purpose of the class is to allocate (and free) array with multiple indices dynamically. This is implemented for up to 4 indices yet, but might extended further in future versions.

  The allocation is done but allocation arrays of pointer for each index but the last. This arrays point into an array responsable for the consequitive index. Therefore arrays of this type can be used like C-style arrays with multiple indices, altough they are created dynamically. However, there is some extra memory required for the pointer arrays.

  All methods in this template class are static.

  • static TYPE * alloc(int n1)
    Allocates an array with one index of size n1.
  • static TYPE ** alloc(int n1, int n2)
    Allocates an array with two indices analog to a C-style array A[n1][n2].
  • static TYPE ** alloc2(int *n)
    Same as static TYPE ** alloc(int n1, int n2) but the dimesions are given in the array *n.
  • static TYPE *** alloc(int n1,int n2,int n3)
    Allocates an array with three indices analog to a C-style array A[n1][n2][n3].
  • static TYPE *** alloc3(int *n)
    Same as static TYPE ** alloc(int n1, int n2,int n3) but the dimesions are given in the array *n.
  • static TYPE **** alloc(int n1,int n2,int n3, int n4)
    Allocates an array with four indices analog to a C-style array A[n1][n2][n3][n4].
  • static TYPE **** alloc4(int *n)
    Same as static TYPE ** alloc(int n1, int n2,int n3,int n4) but the dimesions are given in the array *n.
  • static void free(void *v)
    Free the memory for any Array allocated by any of teh above methods.

Measuring Runtime

• class Timer
  

  This class is meant to measure run times of parts of your programs internally.

  • void start()
    Start the Measurement
  • void stop()
    Stop the Measurement
  • void stopIntermediate()
    Take an intermediate runtime value.
  • float cputime()
    Returns the CPU time used measured in seconds.
  • float cputimeIntermediate()
    Returns the CPU time used at the intermediate stop measured in seconds.
  • float runtime()
    Returns the real time elasped measured in seconds.
  • runtimeIntermediate()
    Returns the real time elaspedat the intermediate stop measured in seconds.
  • void report(const char *task)
    Print the following string:
    Time for TASK : CPUTIME CPU-seconds,REALTIME s real time
    where TASK, CPUTIME, REALTIME is replaced by the string argument of the function, the CPU time used and the real time elasped, respectively.
  • void reportIntermediate(const char *task)
    Same as report() but the intermediate measurement is reported.

Parameter file parser

Vector class (3dim-Vector)

Variable sized math type Vector class

Variable sized math type Matrix class

Simple Thread Scheduling class

• class RutiThreadScheduler
  

  The idea of this class is to have a simple option to start multithreading of independeant tasks. Each task is defined by a class or struct an function. A thread is started by calling the function with a pointer to the class or struct as (void *) argument. The scheduler takes care that the requested amount of threads is running until all tasks are done

  The class has the follwoing methods:

  • void addTask(RutiThreadFunction func, void * data)
    A Task with the data in data is added to the task list. the task will be started unsing the function func.
  • void addTask(RutiThreadFunction func, void **data , int size)
    Size tasks are added to the task list. The data is found in the pointer array data. There is no check if data contains less than size pointers.
    All Task will be started using the fucntion func.
  • void addTask(RutiThreadFunction func, void *data , int len, int size)
    Size tasks are added to the task list. The data is found in the data array data. Each element in data is len bytes (or whatever sizeof reprots) long and the array must have at least size of those structures. All Task will be started using the fucntion func.
  • void schedule(int threads)
    This method starts doing the tasks add before. It will use threads Threads. The Methdod will terminate after the last thread is finished.
  • void reset()
    Clears the lsit of tasks.

  The task-functions must follow this definition:

  typedef void * (*RutiThreadFunction) (void *);

  In order to use the Thread Scheduler, you must add

  #include <ruti/scheduler.h>