utils.c File Reference

#include "../headers/utils.h"

Go to the source code of this file.

Functions
void	start_rand_generator (void)
float	rand_uniform (float min, float max)
tab_str *	f_readl (const char *fpath, int nchar_max)
float	float_get_max_in_2D_array (float **t, size_t n, int col)
float	float_get_min_in_2D_array (float **t, size_t n, int col)
void	free_tab_str (tab_str *tstr)
void	print_tab_str (tab_str *strings)
int	str_is_number (const char *str, const int sign)
int	str_is_float (const char *str, const int sign)
int	in_tab (int *tab, int size, int val)
int	index_of (int *tab, int size, int val)
void	str_trim (char *str)
void	extract_path (char *str, char *dest)
void	extract_ext (char *str, char *dest)
void	remove_path (char *str)
void	remove_ext (char *str)
FILE *	fopen_pdb_check_case (char *name, const char *mode)
tab_str *	str_split (const char *str, const int sep)
Variables
static int	ST_is_rand_init = 0

---

Function Documentation

void extract_ext	(	char *	str,
		char *	dest
	)

## FUNCTION: extract_ext

## SPECIFICATION: Get rid of the extension of a string (.pdb eg.)

## PARAMETRES: @ char *str: String to deal with @ char *dest : OUTPUT The destination string

## RETURN:

Definition at line 601 of file utils.c.

{
        char *pstr = str,
                 *last_dot = NULL ;
        
        while(*pstr) {
        /* Advance in the path name while it is possible */
                if(*pstr == '.') {
                /* If we encounter a '/', save its position */
                        last_dot = pstr ;
                }
                pstr ++ ;
        }

        if(last_dot) {
                strcpy(dest, last_dot+1) ;
        }
        else {
        /* If no '/' has been found, just return a dot as current folder  */
                dest[0] = '\0' ;
        }
}

void extract_path	(	char *	str,
		char *	dest
	)

## FUNCTION: extract_path

## SPECIFICATION: Extract path from a string

## PARAMETRES: @ char *str : String to deal with @ char *dest : OUTPUT The destination string

## RETURN:

Definition at line 558 of file utils.c.

Referenced by write_out_fpocket(), and write_out_fpocket_DB().

{
        char sav ;      
        char *pstr = str,
                 *last_backsl = NULL ;
        
        while(*pstr) {
        /* Advance in the path name while it is possible */
                if(*pstr == '/') {
                /* If we encounter a '/', save its position */
                        last_backsl = pstr ;
                }
                pstr ++ ;
        }

        if(last_backsl) {
        /* If we have found one '/' at least, copy the path */
                sav = *(last_backsl) ;
                (*last_backsl) = '\0' ;

                strcpy(dest, str) ;
                (*last_backsl) = sav ;  
        }
        else {
        /* If no '/' has been found, just return a dot as current folder  */
                dest[0] = '\0' ;
        }
}

tab_str* f_readl	(	const char *	fpath,
		int	nchar_max
	)

## FUNCTION: tab_str* f_readl(const char fpath[], int nchar_max)

## SPECIFICATION: Read file line and store them in a tab_str structure. The function skip empty lines.

## PARAMETRES: @ const char *fpath : Full path of the file. @ int nchar_max : A number giving the max number of caractere in each line.

## RETURN: tab_str* : Pointer to the sab_str structure containing lines of the file.

Definition at line 156 of file utils.c.

References my_free(), my_malloc(), tab_str::nb_str, and tab_str::t_str.

{
/*  Variable declaration */

        FILE *f ;
        int i, n,
                nb_string ;
        char *cline,
                 **f_lines ;
        tab_str *lines ;

/*  Variable initialisation */

        i = nb_string = 0 ;
        cline = (char *) my_malloc(nchar_max*sizeof(char)) ;

/*  How many lines is there in the file? */

        f = fopen(fpath, "r") ;
        if(f == NULL) {
                my_free(cline) ;
                return NULL ;
        }
        
        while(fgets(cline, nchar_max, f) != NULL) {
                if(strcmp("\n", cline) != 0) {
                        nb_string ++ ;
                }
        }
        fclose(f) ;

/*  Once we have the number of lines, lets allocate memory and get the lines */

        f = fopen(fpath, "r") ;
        if(f == NULL) {
                my_free(cline) ;
                return NULL ;
        }

        lines = (tab_str *)my_malloc(sizeof(tab_str)) ;
        f_lines = (char **)my_malloc(nb_string*sizeof(char*)) ;
        
/*  Getting lines. */

        while(fgets(cline, nchar_max, f) != NULL) {
                if(strcmp("\n", cline) != 0) {
                        n = strlen(cline) ;
                        if(cline[n-1] == '\n') {
                                n-- ;
                                cline[n] = '\0' ;
                        }
                        
                        char *line =(char *) my_malloc((n+1)*sizeof(char)) ;
                        memcpy (line, cline, n+1);
        
                        f_lines[i] = line ;
                        i++ ;
                }
        }

        lines->nb_str  = nb_string ;
        lines->t_str = f_lines ;

/*  Free memory and close file */

        fclose(f) ;
        my_free(cline);
 
        return lines ;
}

float float_get_max_in_2D_array	(	float **	t,
		size_t	n,
		int	col
	)

## FUNCTION: float_get_max_in_2D_array

## SPECIFICATION: receive the maximum value in a give column in a 2D float array

## PARAMETRES: @ **t float : pointer to pointer to float (2D float array) @ n int : size of the array (number of lines) @ col int : column on which the maximum is to extract

## RETURN: float

Definition at line 243 of file utils.c.

                                                           {
    float c=0.0,m=-1e15;
    size_t i;
    for(i=0;i<n;i++){
        c=t[i][col];
        if(c>m)m=c;
    }
    return m;
}

float float_get_min_in_2D_array	(	float **	t,
		size_t	n,
		int	col
	)

## FUNCTION: float_get_min_in_2D_array

## SPECIFICATION: receive the minimum value in a give column in a 2D float array

## PARAMETRES: @ **t float : pointer to pointer to float (2D float array) @ n int : size of the array (number of lines) @ col int : column on which the minimum is to extract

## RETURN: float

Definition at line 269 of file utils.c.

                                                           {
    float c=0.0,m=1e15;
    size_t i;
    for(i=0;i<n;i++){
        c=t[i][col];
        if(c<m)m=c;
    }
    return m;
}

FILE* fopen_pdb_check_case	(	char *	name,
		const char *	mode
	)

## FUNCTION: fopen_pdb_check_case

## SPECIFICATION: Try to open a pdb file. If the open failed, put the 4 letter before extention at the lower case and try again. This function assume that the file name has the format path/file.pdb !

## PARAMETERS: @ char *name : The string to parse @ const char *mode : Opening mode

## RETURN: The file, NULL if the openning fails.

Definition at line 714 of file utils.c.

Referenced by add_complexe(), add_prot(), add_snapshot(), and rpdb_open().

{
        FILE *f = fopen(name, mode) ;
        if(!f) {
                int len = strlen(name) ;
                name[len-5] = toupper(name[len-5]);
                name[len-6] = toupper(name[len-6]);
                name[len-7] = toupper(name[len-7]);
                name[len-8] = toupper(name[len-8]);

                f = fopen(name, mode) ;
                if(!f) {
                        name[len-5] = tolower(name[len-5]);
                        name[len-6] = tolower(name[len-6]);
                        name[len-7] = tolower(name[len-7]);
                        name[len-8] = tolower(name[len-8]);
                        f = fopen(name, mode) ;
                        
                }
        }

        return f ;
        
}

void free_tab_str

(

tab_str *

tstr

)

## FUNCTION: free_tab_str

## SPECIFICATION: Free the given structure

## PARAMETRES: @ tab_str* strings : Pointer to the tab_str to print

## RETURN: void

Definition at line 294 of file utils.c.

References my_free(), tab_str::nb_str, and tab_str::t_str.

{
        if(tstr) {
                int i ;
                if(tstr->t_str) {
                        for(i = 0 ; i < tstr->nb_str ; i++) {
                                if(tstr->t_str[i]) {
                                        my_free(tstr->t_str[i]) ;
                                        tstr->t_str[i] = NULL ;
                                }
                        }
                        my_free(tstr->t_str) ;
                }

                my_free(tstr) ;
        }
}

int in_tab	(	int *	tab,
		int	size,
		int	val
	)

## FUNCTION: in_tab

## SPECIFICATION: Check if val is present in tab.

## PARAMETRES: @ int *tab: Tab @ int size: Size of the tab @ int val: Value to check

## RETURN: int: 1 if val is in tab, 0 if not

Definition at line 475 of file utils.c.

Referenced by count_pocket_contacted_atms(), get_pocket_contacted_atms(), get_surrounding_atoms_idx(), get_unique_atoms(), get_vert_contacted_atms(), and set_atom_based_descriptors().

{
        if(tab) {
                int i ;
                for(i = 0 ; i < size ; i++) {
                        if(tab[i] == val) return 1 ;
                }
        }
        
        return 0 ;
}

int index_of	(	int *	tab,
		int	size,
		int	val
	)

## FUNCTION: index_of

## SPECIFICATION: Check if val is present in tab and return its index if so

## PARAMETRES: @ int *tab: Tab @ int size: Size of the tab @ int val: Value to check

## RETURN: int: index if val is in tab, -1 if not

Definition at line 503 of file utils.c.

{
        if(tab) {
                int i;
                for(i = 0 ; i < size ; i++) {
                        if(val == tab[i]) return i ;
                }
        }
        
        return -1 ;
}

void print_tab_str

(

tab_str *

strings

)

## FUNCTION: print_tab_str

## SPECIFICATION: Print strings contained in the given tab_str.

## PARAMETRES: @ tab_str* strings : Pointer to the tab_str to print

## RETURN: void

Definition at line 326 of file utils.c.

References tab_str::nb_str, and tab_str::t_str.

{
        if(strings) {
                int i ;
                char **strs = strings->t_str ;
                
                printf("\n-- String tab: \n");
                for (i = 0 ; i < strings->nb_str ; i++) {
                        fprintf(stdout, "<%s>\n", strs[i]) ;
                }
                printf("--\n") ;
        }
        else {
                fprintf(stderr, "! Argument NULL in print_tab_str().\n");
        }
}

float rand_uniform	(	float	min,
		float	max
	)

## FONCTION: rand_uniform

## SPECIFICATION: Generate a random number between 0 and 1 using a uniform distribution.

## PARAMETRES: @ float min : Lower boundary @ float max : Upper boundary

## RETURN: double: A uniform random number between min and max

Definition at line 123 of file utils.c.

References ST_is_rand_init, and start_rand_generator().

Referenced by get_mol_volume_ptr(), get_verts_volume_ptr(), set_mc_overlap_volume(), and set_pocket_mtvolume().

{
        if(ST_is_rand_init == 0){
                start_rand_generator() ;
        }

        float rnd = 0.0 ;       

        #ifdef MD_USE_GSL       /* GSL */
                rnd = gsl_rng_uniform(ST_r) * (max-min) ;
        #else                           /* /GSL */
                rnd = ((float)rand()/(float)RAND_MAX) * (max-min) ;
        #endif

        return min+rnd ;
}

void remove_ext

(

char *

str

)

## FUNCTION: remove_ext

## SPECIFICATION: Remove the extention of a given string

## PARAMETRES: @ char *str: INOUT String to deal with

## RETURN: The input string is modified

Definition at line 678 of file utils.c.

Referenced by get_dpocket_args(), get_mdpocket_args(), mdpocket_detect(), write_out_fpocket(), write_out_fpocket_DB(), write_pymol(), and write_vmd().

{
        char *pstr = str,
                 *last_dot = NULL ;
        
        while(*pstr) {
        /* Advance in the path name while it is possible */
                if(*pstr == '.') {
                /* If we encounter a '/', save its position */
                        last_dot = pstr ;
                }
                pstr ++ ;
        }

        if(last_dot) {
                *last_dot = '\0' ;
        }
}

void remove_path

(

char *

str

)

## FUNCTION: remove_path

## SPECIFICATION: Remove the path from a string

## PARAMETRES: @ char *str: INOUT String to deal with

## RETURN: The input string is modified

Definition at line 638 of file utils.c.

Referenced by mdpocket_detect(), test_fpocket(), write_out_fpocket(), write_out_fpocket_DB(), write_pymol(), and write_vmd().

{
        int i, filelen ;
        char *pstr = str,
                 *last_backsl = NULL ;
        
        while(*pstr) {
        /* Advance in the path name while it is possible */
                if(*pstr == '/') {
                /* If we encounter a '/', save its position */
                        last_backsl = pstr ;
                }
                pstr = pstr + 1 ;
        }

        if(last_backsl) {
        /* If we have found one '/' at least, copy the path, else dont do anything */
                last_backsl = last_backsl + 1 ;
                filelen = strlen(last_backsl) ;
                for(i = 0 ; i < filelen ; i++) {
                        str[i] = *(last_backsl+i) ;
                }
                str[i] = '\0' ;
        }
}

void start_rand_generator

(

void

)

## FONCTION: start_rand_generator

## SPECIFICATION: Initialize generator. This initialisation depends on the library to use.

## PARAMETRES:

## RETURN: void

Definition at line 81 of file utils.c.

References ST_is_rand_init.

Referenced by rand_uniform().

{
        if(ST_is_rand_init == 0) {

        #ifdef MD_USE_GSL       /* use GSL if defined */
/*              fprintf(stdout, "> GSL generator used\n"); */
                if(ST_r != NULL) {
                        gsl_rng_free(ST_r);
                }

                gsl_rng_default_seed = time(NULL);

                const gsl_rng_type *T = M_GEN_MTWISTER ;
                ST_r = gsl_rng_alloc(T);
                gsl_rng_set (ST_r, gsl_rng_default_seed);

        #else                           /* /GSL */

/*              fprintf(stdout, "> Standard C generator used\n"); */
                srand((int)time(NULL));

        #endif
                ST_is_rand_init = 1 ;
        }
}

int str_is_float	(	const char *	str,
		const int	sign
	)

## FUNCTION: str_is_float

## SPECIFICATION: Check if the string given in argument is a valid float.

## PARAMETRES: @ char *str : The string to deal with @ const int sign : The first caractere is the sign?

## RETURN: int: 1 if its a valid float, 0 else

Definition at line 412 of file utils.c.

Referenced by parse_asph_max_size(), parse_asph_min_size(), parse_clust_max_dist(), parse_dist_crit(), parse_lig_neigh_dist(), parse_mc_niter(), parse_refine_dist(), parse_refine_minaap(), and parse_sclust_max_dist().

{
        int ok = 0 ;
        int nb_dot = 0 ;

        if (str != NULL) {
                const char *p = str ;
                int c = *p ;

                /* Checkthe first caractere if the sign has to be taken into account */
                if (sign) {     

                        if(isdigit (c) || ((c == '+' || c == '-') && str[1] != 0)) {
                                ok = 1 ;
                        }
                        p++;
                }
                else {
                        ok = 1 ;
                }

                if (ok) {
                        while (*p != 0) {
                                if (!isdigit (*p)) {
                                        if((*p) == '.') {
                                                nb_dot++ ;
                                                if(nb_dot > 1) {
                                                        ok = 0;
                                                        break ;
                                                }
                                        }
                                        else {
                                                ok = 0;
                                                break ;
                                        }
                                }
                                p++;
                        }
                }
        }
        else {
                fprintf(stderr, "! Argument NULL in str_is_number().\n");
        }

        return ok;
}

int str_is_number	(	const char *	str,
		const int	sign
	)

## FUNCTION: str_is_number

## SPECIFICATION: Check if the string given in argument is a number.

## PARAMETRES: @ char *str : The string to deal with @ const int sign : The first caractere is the sign?

## RETURN: int: 1 if its a valid number, 0 else

Definition at line 359 of file utils.c.

Referenced by is_N(), parse_basic_vol_div(), parse_min_apol_neigh(), parse_min_pock_nb_asph(), and parse_sclust_min_nneigh().

{
        int ok = 0 ;

        if (str != NULL) {
                const char *p = str ;
                int c = *p ;

                /* Checkthe first caractere if the sign has to be taken into account */
                if (sign) {

                        if(isdigit (c) || ((c == '+' || c == '-') && str[1] != 0)) {
                                ok = 1 ;
                        }
                        p++;
                }
                else {
                        ok = 1 ;
                }

                if (ok) {
                        while (*p != 0) {
                                if (!isdigit (*p)) {
                                        ok = 0;
                                        break ;
                                }
                                p++;
                        }
                }
        }
        else {
                fprintf(stderr, "! Argument NULL in str_is_number().\n");
        }

        return ok;
}

tab_str* str_split	(	const char *	str,
		const int	sep
	)

## FONCTION: tab_str* str_split_memopt(const char *str, const char sep)

## SPECIFICATION: Split the string given using a char separator. Every token will be stored in a tab_str structure which will be returned by the function. Empty tokens (two consecutives separator) will be stored as an empty string containing only the NULL caractere.

We optimise here the memory, and allocate the exact memory for each token.

!! MEMORY OF THE RETURNED ARGUMENT MUST BE FREED BY CALLING free_tab_str() !!

COULD BE OPTIMISED.

## PARAMETRES: @ const char *str: The string to deal with @ const char sep: The separator

## RETURN: tab_str*: A pointer to a structure tab_str which will contain all elements of the string.

Definition at line 764 of file utils.c.

References my_calloc(), tab_str::nb_str, and tab_str::t_str.

{
        tab_str *ts = (tab_str*) my_calloc(1, sizeof(tab_str)) ;

        const char *pstr = str ;        // A temp pointer to str
        int n = 1 ;                                     // At least one token (no separator in the string)

        //  Count the number of token

        while(*pstr) {
                if(*pstr == sep) {
                        n++ ;
                }
                pstr ++ ;
        }

        ts->nb_str = n ;
        ts->t_str = (char**)my_calloc(n, sizeof(char*)) ;

        //  If there is more than one token, split the string

        if(n > 1) {
                char **ptab_str = ts->t_str ;
                char *s_pctok = NULL ;                  // A pointer to the current created token
                const char *s_beg = str ;               // A pointer used to copy each token from s_beg to next separator

                size_t tok_i = 0,
                           size_tok = 1 ;

                pstr = str ;

                //  Allocate exact memory and copy each tokens

                while(*pstr) {
                        if(*pstr == sep) {
                                ptab_str[tok_i] = (char*)my_calloc(size_tok, sizeof(char)) ;
                                s_pctok = ptab_str[tok_i] ;

                                while(*s_beg != *pstr) {
                                        *s_pctok = *s_beg ;
                                        s_pctok ++ ;
                                        s_beg ++ ;
                                }
                                *s_pctok = '\0' ;

                                size_tok = 0 ;
                                tok_i ++ ;
                                s_beg ++ ;              // Skip the separator for next token
                        }
                        size_tok ++ ;
                        pstr ++ ;
                }

        //  Copy the last token

                ptab_str[tok_i] =  (char*)my_calloc(size_tok, sizeof(char)) ;
                s_pctok = ptab_str[tok_i] ;
                while(*s_beg) {
                        *s_pctok = *s_beg ;
                        s_pctok ++ ;
                        s_beg ++ ;
                }
                *s_pctok = '\0' ;
        }
        else {
        //  One token only, just copy the original string
                ts->t_str[0] =  (char*)my_calloc(strlen(str), sizeof(char));
                strcpy(ts->t_str[0], str);
        }

        return ts ;

}

void str_trim

(

char *

str

)

## FUNCTION: str_trim

## SPECIFICATION: Remove spaces from a given string

## PARAMETRES: @ char *str: String to deal with

## RETURN:

Definition at line 528 of file utils.c.

Referenced by guess_element(), is_valid_element(), is_valid_nucl_acid_element(), is_valid_prot_element(), load_pdb_line(), rpdb_extract_atm_resname(), and rpdb_extract_pdb_atom().

{
        int i, len;
        
        len = strlen(str);
        while (len > 0 && str[len-1] == ' ') {
                str[len-1] = '\0';
                len--;
        }
        
        while (len > 0 && str[0] == ' ') {
                for (i=0; i < len; i++) str[i] = str[i+1];
                len--;
        }
}

---

Variable Documentation

int ST_is_rand_init = 0 [static]

Says wether we have seeded the generator.

Definition at line 62 of file utils.c.

Referenced by rand_uniform(), and start_rand_generator().