/** It is a bug to call this before some function has set the size. */ void gen_data_realloc_data(gen_data_type * gen_data) { int byte_size = gen_data_config_get_byte_size(gen_data->config , gen_data->current_report_step ); gen_data->data = util_realloc(gen_data->data , byte_size ); }
int matrix_dsyevx(bool compute_eig_vectors , dsyevx_eig_enum which_values , /* DSYEVX | DSYEVX_VALUE_INTERVAL | DSYEVX_INDEX_INTERVAL */ dsyevx_uplo_enum uplo, matrix_type * A , /* The input matrix - is modified by the dsyevx() function. */ double VL , /* Lower limit when using DSYEVX_VALUE_INTERVAL */ double VU , /* Upper limit when using DSYEVX_VALUE_INTERVAL */ int IL , /* Lower index when using DSYEVX_INDEX_INTERVAL */ int IU , /* Upper index when using DSYEVX_INDEX_INTERVAL */ double *eig_values , /* The calcualated eigenvalues */ matrix_type * Z ) { /* The eigenvectors as columns vectors */ int lda = matrix_get_column_stride( A ); int n = matrix_get_rows( A ); char jobz; char range; char uplo_c; if (compute_eig_vectors) jobz = 'V'; else jobz = 'N'; switch(which_values) { case(DSYEVX_ALL): range = 'A'; break; case(DSYEVX_VALUE_INTERVAL): range = 'V'; break; case(DSYEVX_INDEX_INTERVAL): range = 'I'; break; default: util_abort("%s: internal error \n",__func__); } if (uplo == DSYEVX_AUPPER) uplo_c = 'U'; else if (uplo == DSYEVX_ALOWER) uplo_c = 'L'; else util_abort("%s: internal error \n",__func__); if (!matrix_is_quadratic( A )) util_abort("%s: matrix A must be quadratic \n",__func__); { int num_eigenvalues , ldz, info , worksize; int * ifail = util_calloc( n , sizeof * ifail ); int * iwork = util_calloc( 5 * n , sizeof * iwork ); double * work = util_calloc( 1 , sizeof * work ); double * z_data; double abstol = 0.0; /* SHopuld */ if (compute_eig_vectors) { ldz = matrix_get_column_stride( Z ); z_data = matrix_get_data( Z ); } else { /* In this case we can accept that Z == NULL */ ldz = 1; z_data = NULL; } /* First call to determine optimal worksize. */ worksize = -1; info = 0; dsyevx_( &jobz, /* 1 */ &range, /* 2 */ &uplo_c, /* 3 */ &n, /* 4 */ matrix_get_data( A ), /* 5 */ &lda , /* 6 */ &VL , /* 7 */ &VU , /* 8 */ &IL , /* 9 */ &IU , /* 10 */ &abstol , /* 11 */ &num_eigenvalues , /* 12 */ eig_values , /* 13 */ z_data , /* 14 */ &ldz , /* 15 */ work , /* 16 */ &worksize , /* 17 */ iwork , /* 18 */ ifail , /* 19 */ &info); /* 20 */ worksize = (int) work[0]; { double * tmp = realloc(work , sizeof * work * worksize ); if (tmp == NULL) { /* OK - we could not get the optimal worksize, try again with the minimum. */ worksize = 8 * n; work = util_realloc(work , sizeof * work * worksize ); } else work = tmp; /* The request for optimal worksize succeeded */ } /* Second call: do the job */ info = 0; dsyevx_( &jobz, &range, &uplo_c, &n, matrix_get_data( A ), &lda , &VL , &VU , &IL , &IU , &abstol , &num_eigenvalues , eig_values , z_data , &ldz , work , &worksize , iwork , ifail , &info); free( ifail ); free( work ); free( iwork ); return num_eigenvalues; } }
static char * fscanf_alloc_grdecl_data( const char * header , bool strict , ecl_type_enum ecl_type , int * kw_size , FILE * stream ) { char newline = '\n'; bool atEOF = false; int init_size = 32; int buffer_size = 64; int data_index = 0; int sizeof_ctype = ecl_util_get_sizeof_ctype( ecl_type ); int data_size = init_size; char * buffer = util_calloc( (buffer_size + 1) , sizeof * buffer ); char * data = util_calloc( sizeof_ctype * data_size , sizeof * data ); while (true) { if (fscanf(stream , "%32s" , buffer) == 1) { if (strcmp(buffer , ECL_COMMENT_STRING) == 0) { // We have read a comment marker - just read up to the end of line. char c; while (true) { c = fgetc( stream ); if (c == newline) break; if (c == EOF) { atEOF = true; break; } } } else if (strcmp(buffer , ECL_DATA_TERMINATION) == 0) break; else { // We have read a valid input string; scan numerical input values from it. // The multiplier algorithm will fail hard if there are spaces on either side // of the '*'. int multiplier; void * value_ptr = NULL; bool char_input = false; if (ecl_type == ECL_INT_TYPE) { int value; if (sscanf(buffer , "%d*%d" , &multiplier , &value) == 2) {} else if (sscanf( buffer , "%d" , &value) == 1) multiplier = 1; else { char_input = true; if (strict) util_abort("%s: Malformed content:\"%s\" when reading keyword:%s \n",__func__ , buffer , header); } value_ptr = &value; } else if (ecl_type == ECL_FLOAT_TYPE) { float value; if (sscanf(buffer , "%d*%g" , &multiplier , &value) == 2) {} else if (sscanf( buffer , "%g" , &value) == 1) multiplier = 1; else { char_input = true; if (strict) util_abort("%s: Malformed content:\"%s\" when reading keyword:%s \n",__func__ , buffer , header); } value_ptr = &value; } else if (ecl_type == ECL_DOUBLE_TYPE) { double value; if (sscanf(buffer , "%d*%lg" , &multiplier , &value) == 2) {} else if (sscanf( buffer , "%lg" , &value) == 1) multiplier = 1; else { char_input = true; if (strict) util_abort("%s: Malformed content:\"%s\" when reading keyword:%s \n",__func__ , buffer , header); } value_ptr = &value; } else util_abort("%s: sorry type:%s not supported \n",__func__ , ecl_util_get_type_name(ecl_type)); if (char_input) fprintf(stderr,"Warning: character string: \'%s\' ignored when reading keyword:%s \n",buffer , header); else { if (data_index + multiplier >= data_size) { data_size = 2*(data_index + multiplier); data = util_realloc( data , sizeof_ctype * data_size * sizeof * data); } iset_range( data , data_index , sizeof_ctype , value_ptr , multiplier ); data_index += multiplier; } } if (atEOF) break; } else break; } free( buffer ); *kw_size = data_index; data = util_realloc( data , sizeof_ctype * data_index * sizeof * data ); return data; }