void test_active_index_list() { int default_value = -1; bool_vector_type * mask = bool_vector_alloc(0 , false); bool_vector_iset(mask , 10, true); bool_vector_iset(mask , 15, true); bool_vector_iset(mask , 20, true); { int_vector_type * active_index_list = bool_vector_alloc_active_index_list(mask , default_value); test_assert_int_equal( default_value , int_vector_get_default(active_index_list)); test_assert_int_equal( 21 , int_vector_size( active_index_list )); test_assert_int_equal( default_value , int_vector_iget( active_index_list , 0)); test_assert_int_equal( default_value , int_vector_iget( active_index_list , 1)); test_assert_int_equal( default_value , int_vector_iget( active_index_list , 12)); test_assert_int_equal( default_value , int_vector_iget( active_index_list , 19)); test_assert_int_equal( 0 , int_vector_iget( active_index_list , 10)); test_assert_int_equal( 1 , int_vector_iget( active_index_list , 15)); test_assert_int_equal( 2 , int_vector_iget( active_index_list , 20)); int_vector_free( active_index_list); } bool_vector_free(mask); }
void obs_vector_measure(const obs_vector_type * obs_vector , enkf_fs_type * fs , state_enum state , int report_step , const int_vector_type * ens_active_list , meas_data_type * meas_data , const active_list_type * active_list) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node != NULL ) { enkf_node_type * enkf_node = enkf_node_deep_alloc( obs_vector->config_node ); node_id_type node_id = { .report_step = report_step , .state = state , .iens = 0 }; for (int active_iens_index =0; active_iens_index < int_vector_size( ens_active_list ); active_iens_index++) { node_id.iens = int_vector_iget( ens_active_list , active_iens_index ); enkf_node_load(enkf_node , fs , node_id); obs_vector->measure(obs_node , enkf_node_value_ptr(enkf_node) , node_id , meas_data , active_list); } enkf_node_free( enkf_node ); } }
static bool_vector_type * alloc_mask( const int_vector_type * active_list ) { bool_vector_type * mask = bool_vector_alloc( 0 , false ); int i; for (i=0; i < int_vector_size( active_list ); i++) bool_vector_iset( mask , int_vector_iget( active_list , i) , true ); return mask; }
int state_map_get_size( state_map_type * map) { int size; pthread_rwlock_rdlock( &map->rw_lock ); { size = int_vector_size( map->state ); } pthread_rwlock_unlock( &map->rw_lock ); return size; }
const int_vector_type * nnc_info_get_index_list(const nnc_info_type * nnc_info, int lgr_nr) { int_vector_type * ret = NULL; if (int_vector_size(nnc_info->lgr_index_map) > lgr_nr) { int lgr_index = int_vector_iget(nnc_info->lgr_index_map, lgr_nr); if (-1 != lgr_index) { ret = vector_iget(nnc_info->lgr_list, lgr_index); } } return ret; }
void test_div() { int_vector_type * int_vector = int_vector_alloc( 0 , 100); int_vector_iset( int_vector , 10 , 100 ); int_vector_div( int_vector , 10 ); { int i; for (i=0; i < int_vector_size( int_vector ); i++) test_assert_int_equal( 10 , int_vector_iget( int_vector , i )); } }
bool string_util_update_active_mask( const char * range_string , bool_vector_type * active_mask) { int i; int_vector_type * sscanf_active = string_util_sscanf_alloc_active_list( range_string ); if (sscanf_active) { for (i=0; i < int_vector_size( sscanf_active ); i++) bool_vector_iset( active_mask , int_vector_iget(sscanf_active , i) , true ); int_vector_free( sscanf_active ); return true; } else return false; }
void test_alloc() { const int size = 100; const int default_value = 77; int_vector_type * v = int_vector_alloc(size , default_value); test_assert_int_equal(size , int_vector_size(v)); for (int i=0; i < size; i++) test_assert_int_equal( default_value , int_vector_iget( v , i)); int_vector_free( v); }
bool nnc_info_equal( const nnc_info_type * nnc_info1 , const nnc_info_type * nnc_info2 ) { if (nnc_info1 == nnc_info2) return true; if ((nnc_info1 == NULL) || (nnc_info2 == NULL)) return false; { if (nnc_info1->lgr_nr != nnc_info2->lgr_nr) return false; if ((int_vector_size( nnc_info1->lgr_index_map ) > 0) && (int_vector_size( nnc_info2->lgr_index_map ) > 0)) { int max_lgr_nr = util_int_max( int_vector_size( nnc_info1->lgr_index_map ), int_vector_size( nnc_info2->lgr_index_map ) ); int lgr_nr = 0; while (true) { nnc_vector_type * vector1 = nnc_info_get_vector( nnc_info1 , lgr_nr ); nnc_vector_type * vector2 = nnc_info_get_vector( nnc_info2 , lgr_nr ); if (!nnc_vector_equal(vector1 , vector2)) return false; lgr_nr++; if (lgr_nr > max_lgr_nr) return true; } } else { if (int_vector_size( nnc_info1->lgr_index_map ) == int_vector_size( nnc_info2->lgr_index_map )) return true; else return false; } } }
void test_neighbours( const ecl_grid_type * grid) { const int k = 0; fault_block_layer_type * layer = fault_block_layer_alloc( grid , k ); geo_polygon_collection_type * polylines = geo_polygon_collection_alloc(); ecl_kw_type * ecl_kw = ecl_kw_alloc("FAULTBLK" , ecl_grid_get_global_size( grid ) , ECL_INT_TYPE ); ecl_kw_iset_int( ecl_kw , 0 , 1); ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 3,3,k) , 2); ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,3,k) , 3); ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 5,3,k) , 4); ecl_kw_iset_int( ecl_kw , ecl_grid_get_global_index3( grid , 4,2,k) , 5); fault_block_layer_load_kw( layer , ecl_kw); { int_vector_type * neighbours = int_vector_alloc( 0,0); { fault_block_type * block = fault_block_layer_get_block( layer , 1 ); test_assert_int_equal( 0 , int_vector_size( neighbours )); fault_block_list_neighbours( block , false , polylines , neighbours ); test_assert_int_equal( 0 , int_vector_size( neighbours )); } { fault_block_type * block = fault_block_layer_get_block( layer , 2 ); fault_block_list_neighbours( block , false , polylines , neighbours ); test_assert_int_equal( 1 , int_vector_size( neighbours )); test_assert_true( int_vector_contains( neighbours , 3 )); } int_vector_free( neighbours ); } geo_polygon_collection_free( polylines ); fault_block_layer_free( layer ); ecl_kw_free( ecl_kw ); }
void test_create(enkf_config_node_type * config_node ) { obs_vector_type * obs_vector = obs_vector_alloc( SUMMARY_OBS , "OBS" , config_node , 100 ); test_assert_true( obs_vector_is_instance( obs_vector )); { const int_vector_type * step_list = obs_vector_get_step_list( obs_vector ); { summary_obs_type * obs_node = summary_obs_alloc( "FOPT" , "FOPT" , 10 , 1 , NULL , 0); obs_vector_install_node( obs_vector , 10 , obs_node ); test_assert_int_equal( 1 , int_vector_size( step_list )); test_assert_int_equal( 10 , int_vector_iget( step_list , 0)); } { summary_obs_type * obs_node = summary_obs_alloc( "FOPT" , "FOPT" , 10 , 1 , NULL , 0); obs_vector_install_node( obs_vector , 10 , obs_node ); test_assert_int_equal( 1 , int_vector_size( step_list )); test_assert_int_equal( 10 , int_vector_iget( step_list , 0)); } { summary_obs_type * obs_node = summary_obs_alloc( "FOPT" , "FOPT" , 10 , 1 , NULL , 0); obs_vector_install_node( obs_vector , 5 , obs_node ); test_assert_int_equal( 2 , int_vector_size( step_list )); test_assert_int_equal( 5 , int_vector_iget( step_list , 0)); test_assert_int_equal( 10 , int_vector_iget( step_list , 1)); } { summary_obs_type * obs_node = summary_obs_alloc( "FOPT" , "FOPT" , 10 , 1 , NULL , 0); obs_vector_install_node( obs_vector , 15 , obs_node ); test_assert_int_equal( 3 , int_vector_size( step_list )); test_assert_int_equal( 5 , int_vector_iget( step_list , 0)); test_assert_int_equal( 10 , int_vector_iget( step_list , 1)); test_assert_int_equal( 15 , int_vector_iget( step_list , 2)); } } obs_vector_free( obs_vector ); }
static void enkf_main_export_runpath_file(enkf_main_type * enkf_main, const int_vector_type * realizations, const int_vector_type * iterations) { ecl_config_type * ecl_config = enkf_main_get_ecl_config(enkf_main); const model_config_type * model_config = enkf_main_get_model_config(enkf_main); const char * basename_fmt = ecl_config_get_eclbase(ecl_config); const char * runpath_fmt = model_config_get_runpath_as_char(model_config); const qc_module_type * qc_module = enkf_main_get_qc_module( enkf_main ); runpath_list_type * runpath_list = runpath_list_alloc( qc_module_get_runpath_list_file( qc_module )); for (int iter = 0; iter < int_vector_size(iterations); ++iter) { for (int iens = 0; iens < int_vector_size(realizations); ++iens) { int iter_value = int_vector_iget(iterations, iter); int iens_value = int_vector_iget(realizations, iens); char * basename; char * runpath; if (basename_fmt) basename = util_alloc_sprintf(basename_fmt, iens_value); else basename = util_alloc_sprintf("--%d", iens_value); if (model_config_runpath_requires_iter(model_config)) runpath = util_alloc_sprintf(runpath_fmt, iens_value, iter_value); else runpath = util_alloc_sprintf(runpath_fmt, iens_value); runpath_list_add(runpath_list, iens_value, iter_value, runpath, basename); free(basename); free(runpath); } } runpath_list_fprintf(runpath_list); runpath_list_free(runpath_list); }
int state_map_count_matching( state_map_type * state_map , int mask) { int count = 0; pthread_rwlock_rdlock( &state_map->rw_lock ); { const int * map_ptr = int_vector_get_ptr(state_map->state); for (int i=0; i < int_vector_size( state_map->state ); i++) { int state_value = map_ptr[i]; if (state_value & mask) count++; } } pthread_rwlock_unlock(&state_map->rw_lock); return count; }
void test_del() { int_vector_type * vec = int_vector_alloc(0,0); test_assert_int_equal( int_vector_del_value( vec , 77) , 0 ); int_vector_append(vec , 1); int_vector_append(vec , 2); int_vector_append(vec , 3); int_vector_append(vec , 1); int_vector_append(vec , 2); int_vector_append(vec , 3); int_vector_append(vec , 1); int_vector_append(vec , 1); int_vector_fprintf( vec , stdout , "int_vector" , "%3d"); test_assert_int_equal( int_vector_del_value( vec , 77) , 0); test_assert_int_equal( int_vector_del_value( vec , 2) , 2 ); test_assert_int_equal( 6 , int_vector_size( vec )); int_vector_fprintf( vec , stdout , "int_vector" , "%3d"); test_assert_int_equal( 1 , int_vector_iget(vec , 0)); test_assert_int_equal( 3 , int_vector_iget(vec , 1)); test_assert_int_equal( 1 , int_vector_iget(vec , 2)); test_assert_int_equal( 3 , int_vector_iget(vec , 3)); test_assert_int_equal( 1 , int_vector_iget(vec , 4)); test_assert_int_equal( 1 , int_vector_iget(vec , 5)); test_assert_int_equal( 4 , int_vector_del_value( vec , 1 )); test_assert_int_equal( 2 , int_vector_size( vec )); test_assert_int_equal( 3 , int_vector_iget(vec , 0)); test_assert_int_equal( 3 , int_vector_iget(vec , 1)); int_vector_free( vec ); }
static void state_map_select_matching__( state_map_type * map , bool_vector_type * select_target , int select_mask , bool select) { pthread_rwlock_rdlock( &map->rw_lock ); { { const int * map_ptr = int_vector_get_ptr( map->state ); for (int i=0; i < int_vector_size( map->state ); i++) { int state_value = map_ptr[i]; if (state_value & select_mask) bool_vector_iset( select_target , i , select); } } pthread_rwlock_unlock( &map->rw_lock ); } }
static int file_map_find_kw_value( const file_map_type * file_map , const char * kw , const void * value) { int global_index = -1; if ( file_map_has_kw( file_map , kw)) { const int_vector_type * index_list = hash_get( file_map->kw_index , kw ); int index = 0; while (index < int_vector_size( index_list )) { const ecl_kw_type * ecl_kw = file_map_iget_kw( file_map , int_vector_iget( index_list , index )); if (ecl_kw_data_equal( ecl_kw , value )) { global_index = int_vector_iget( index_list , index ); break; } index++; } } return global_index; }
static int file_map_find_sim_time(const file_map_type * file_map , time_t sim_time) { int seqnum_index = -1; if ( file_map_has_kw( file_map , INTEHEAD_KW)) { const int_vector_type * intehead_index_list = hash_get( file_map->kw_index , INTEHEAD_KW ); int index = 0; while (index < int_vector_size( intehead_index_list )) { const ecl_kw_type * intehead_kw = file_map_iget_kw( file_map , int_vector_iget( intehead_index_list , index )); if (ecl_rsthead_date( intehead_kw ) == sim_time) { seqnum_index = index; break; } index++; } } return seqnum_index; }
void fault_block_layer_del_block( fault_block_layer_type * layer , int block_id) { int storage_index = int_vector_safe_iget( layer->block_map , block_id); if (storage_index >= 0) { int_vector_iset( layer->block_map , block_id , -1 ); vector_idel( layer->blocks , storage_index ); { int index; for (index = 0; index < int_vector_size( layer->block_map ); index++) { int current_storage_index = int_vector_iget( layer->block_map , index ); if (current_storage_index > storage_index) int_vector_iset( layer->block_map ,index , current_storage_index - 1); } } } }
void nnc_info_fprintf(const nnc_info_type * nnc_info , FILE * stream) { fprintf(stream,"LGR_NR:%d \n",nnc_info->lgr_nr); { int lgr_nr; for (lgr_nr=0; lgr_nr < int_vector_size( nnc_info->lgr_index_map ); lgr_nr++) { int lgr_index = int_vector_iget( nnc_info->lgr_index_map , lgr_nr ); if (lgr_index >= 0) { printf(" %02d -> %02d => ",lgr_nr , lgr_index); { const int_vector_type * index_list = nnc_info_iget_grid_index_list( nnc_info , lgr_index ); int_vector_fprintf( index_list , stream , " " , "%d"); printf("\n"); } } } } fprintf(stream , "\n"); }
int main(int argc , char ** argv) { int lgr_nr = 77; nnc_info_type * nnc_info = nnc_info_alloc(lgr_nr); test_assert_int_equal( 0 , nnc_info_get_total_size( nnc_info )); test_assert_int_equal( lgr_nr , nnc_info_get_lgr_nr( nnc_info )); test_assert_true(nnc_info_is_instance(nnc_info)); test_assert_not_NULL(nnc_info); nnc_info_add_nnc(nnc_info, lgr_nr, 110 , 0); test_assert_int_equal( 1, nnc_info_get_total_size( nnc_info )); nnc_info_add_nnc(nnc_info, 1, 110 , 1); nnc_info_add_nnc(nnc_info, 1, 111 , 2); test_assert_int_equal( 3, nnc_info_get_total_size( nnc_info )); nnc_vector_type * nnc_vector = nnc_info_get_vector( nnc_info , 1); const int_vector_type * nnc_cells = nnc_info_get_grid_index_list(nnc_info, 1); test_assert_int_equal(int_vector_size(nnc_cells), 2); test_assert_ptr_equal( nnc_cells , nnc_vector_get_grid_index_list( nnc_vector )); nnc_vector_type * nnc_vector_null = nnc_info_get_vector( nnc_info , 2); const int_vector_type * nnc_cells_null = nnc_info_get_grid_index_list(nnc_info, 2); test_assert_NULL(nnc_cells_null); test_assert_NULL(nnc_vector_null); nnc_vector_type * nnc_vector_self = nnc_info_get_self_vector( nnc_info ); const nnc_vector_type * nnc_vector_77 = nnc_info_get_vector( nnc_info , lgr_nr ); test_assert_ptr_equal( nnc_vector_77 , nnc_vector_self ); const int_vector_type * nnc_cells_77 = nnc_info_get_grid_index_list(nnc_info, lgr_nr); const int_vector_type * nnc_cells_self = nnc_info_get_self_grid_index_list(nnc_info); test_assert_ptr_equal( nnc_cells_77 , nnc_cells_self ); test_assert_int_equal( 2 , nnc_info_get_size( nnc_info )); test_assert_ptr_equal( nnc_info_get_vector( nnc_info , 1 ) , nnc_info_iget_vector( nnc_info , 1 )); nnc_info_free(nnc_info); exit(0); }
void test_mask() { bool_vector_type * mask = bool_vector_alloc(0 , false); bool_vector_iset(mask , 10, true); bool_vector_iset(mask , 15, true); bool_vector_iset(mask , 20, true); { int_vector_type * index_list = bool_vector_alloc_active_list( mask ); test_assert_int_equal( 3 , int_vector_size( index_list )); test_assert_int_equal( 10 , int_vector_iget( index_list , 0 )); test_assert_int_equal( 15 , int_vector_iget( index_list , 1 )); test_assert_int_equal( 20 , int_vector_iget( index_list , 2 )); int_vector_free( index_list ); } bool_vector_free( mask ); }
static int file_map_iget_occurence( const file_map_type * file_map , int global_index) { const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , global_index); const char * header = ecl_file_kw_get_header( file_kw ); const int_vector_type * index_vector = hash_get( file_map->kw_index , header ); const int * index_data = int_vector_get_const_ptr( index_vector ); int occurence = -1; { /* Manual reverse lookup. */ int i; for (i=0; i < int_vector_size( index_vector ); i++) if (index_data[i] == global_index) occurence = i; } if (occurence < 0) util_abort("%s: internal error ... \n" , __func__); return occurence; }
void nnc_info_add_nnc(nnc_info_type * nnc_info, int lgr_nr, int global_cell_number) { bool index_list_initialized = false; if (int_vector_size(nnc_info->lgr_index_map) > lgr_nr) { int lgr_index = int_vector_iget(nnc_info->lgr_index_map, lgr_nr); if (-1 != lgr_index) { int_vector_append(vector_iget(nnc_info->lgr_list, lgr_index), global_cell_number); index_list_initialized = true; } } if (!index_list_initialized) { int_vector_type * nnc_for_lgr_vec = int_vector_alloc(0,0); int_vector_append(nnc_for_lgr_vec, global_cell_number); vector_append_owned_ref(nnc_info->lgr_list, nnc_for_lgr_vec, int_vector_free__); int_vector_iset(nnc_info->lgr_index_map , lgr_nr, vector_get_size(nnc_info->lgr_list) -1 ); } }
bool field_config_parse_user_key__( const char * index_key , int *i , int *j , int *k) { int length; { int_vector_type * indices = string_util_alloc_value_list( index_key ); length = int_vector_size( indices ); if (length == 3) { *i = int_vector_iget( indices , 0) - 1; *j = int_vector_iget( indices , 1) - 1; *k = int_vector_iget( indices , 2) - 1; } int_vector_free( indices ); } if (length == 3) return true; else return false; }
void test_iset_block() { int_vector_type * vec = int_vector_alloc(0,0); int_vector_iset_block( vec , 10 , 10 , 77 ); test_assert_int_equal( int_vector_size( vec ) , 20 ); { int i; for (i=10; i < 20; i++) test_assert_int_equal( int_vector_iget( vec , i ) , 77 ); } int_vector_iset_block( vec , 10 , 0 , 177 ); test_assert_int_equal( int_vector_iget( vec , 10 ) , 77 ); int_vector_iset_block( vec , 10 , -11 , 66 ); { int i; for (i=0; i <= 10; i++) test_assert_int_equal( int_vector_iget( vec , i ) , 66 ); } int_vector_free( vec ); }
static int ecl_rft_file_get_node_index_time_rft( const ecl_rft_file_type * rft_file , const char * well , time_t recording_time) { int global_index = -1; if (hash_has_key( rft_file->well_index , well)) { const int_vector_type * index_vector = hash_get(rft_file->well_index , well); int well_index = 0; while (true) { if (well_index == int_vector_size( index_vector )) break; { const ecl_rft_node_type * node = ecl_rft_file_iget_node( rft_file , int_vector_iget( index_vector , well_index )); if (ecl_rft_node_get_date( node ) == recording_time) { global_index = int_vector_iget( index_vector , well_index ); break; } } well_index++; } } return global_index; }
void ecl_sum_tstep_fwrite( const ecl_sum_tstep_type * ministep , const int_vector_type * index_map , fortio_type * fortio) { { ecl_kw_type * ministep_kw = ecl_kw_alloc( MINISTEP_KW , 1 , ECL_INT_TYPE ); ecl_kw_iset_int( ministep_kw , 0 , ministep->ministep ); ecl_kw_fwrite( ministep_kw , fortio ); ecl_kw_free( ministep_kw ); } { int compact_size = int_vector_size( index_map ); ecl_kw_type * params_kw = ecl_kw_alloc( PARAMS_KW , compact_size , ECL_FLOAT_TYPE ); const int * index = int_vector_get_ptr( index_map ); float * data = ecl_kw_get_ptr( params_kw ); { int i; for (i=0; i < compact_size; i++) data[i] = ministep->data[ index[i] ]; } ecl_kw_fwrite( params_kw , fortio ); ecl_kw_free( params_kw ); } }
static void __ecl_sum_fprintf_line( const ecl_sum_type * ecl_sum , FILE * stream , int internal_index , const bool_vector_type * has_var , const int_vector_type * var_index , char * date_string , const ecl_sum_fmt_type * fmt) { fprintf(stream , fmt->days_fmt , ecl_sum_iget_sim_days(ecl_sum , internal_index)); fprintf(stream , "%s", fmt->sep ); { struct tm ts; time_t sim_time = ecl_sum_iget_sim_time(ecl_sum , internal_index ); util_localtime( &sim_time , &ts); strftime( date_string , DATE_STRING_LENGTH - 1 , fmt->date_fmt , &ts); fprintf(stream , "%s", date_string ); } { int ivar; for (ivar = 0; ivar < int_vector_size( var_index ); ivar++) { if (bool_vector_iget( has_var , ivar )) { fprintf(stream , "%s", fmt->sep); fprintf(stream , fmt->value_fmt , ecl_sum_iget(ecl_sum , internal_index, int_vector_iget( var_index , ivar ))); } } } fprintf(stream , "%s", fmt->newline); }
int main(int argc , char ** argv) { int_vector_type * int_vector = int_vector_alloc( 0 , 99); int_vector_iset( int_vector , 2 , 0); int_vector_insert( int_vector , 2 , 77 ); int_vector_iset( int_vector , 5 , -10); int_vector_fprintf( int_vector , stdout , "int_vector" , "%3d"); assert_equal( int_vector_iget(int_vector , 0 ) == 99 ); assert_equal( int_vector_iget(int_vector , 1 ) == 99 ); assert_equal( int_vector_iget(int_vector , 2 ) == 77 ); assert_equal( int_vector_iget(int_vector , 3 ) == 00 ); assert_equal( int_vector_iget(int_vector , 4 ) == 99 ); assert_equal( int_vector_iget(int_vector , 5 ) == -10 ); { int N1 = 100000; int N2 = 10*N1; int_vector_type * v1 = int_vector_alloc( N1 , 0 ); int_vector_type * v2; int * data1 = int_vector_get_ptr( v1 ); int_vector_iset( v1 , N1 - 1, 99); int_vector_free_container( v1 ); v2 = int_vector_alloc( N2 , 0 ); int_vector_iset(v2 , N2 - 1, 77 ); test_assert_int_equal( data1[N1-1] , 99); int_vector_free( v2 ); free( data1 ); } test_assert_true( int_vector_init_range( int_vector , 100 , 1000 , 115 ) ); test_assert_int_equal( int_vector_iget( int_vector , 0 ) , 100); test_assert_int_equal( int_vector_iget( int_vector , 1 ) , 215); test_assert_int_equal( int_vector_iget( int_vector , 2 ) , 330); test_assert_int_equal( int_vector_iget( int_vector , 3 ) , 445); test_assert_int_equal( int_vector_get_last( int_vector ) , 1000); test_assert_false( int_vector_init_range( int_vector , 100 , -1000 , 115 ) ); test_assert_int_equal( int_vector_iget( int_vector , 0 ) , 100); test_assert_int_equal( int_vector_iget( int_vector , 1 ) , 215); test_assert_int_equal( int_vector_iget( int_vector , 2 ) , 330); test_assert_int_equal( int_vector_iget( int_vector , 3 ) , 445); test_assert_int_equal( int_vector_get_last( int_vector ) , 1000); { int_vector_type * v1 = int_vector_alloc(0,0); int_vector_type * v2 = int_vector_alloc(0,0); int_vector_append(v1 , 10); int_vector_append(v1 , 15); int_vector_append(v1 , 20); int_vector_append(v2 , 1); int_vector_append(v2 , 2); int_vector_append(v2 , 3); int_vector_append_vector( v1 , v2 ); test_assert_int_equal( int_vector_size( v1 ) , 6 ); test_assert_int_equal( int_vector_iget (v1 , 0 ), 10 ); test_assert_int_equal( int_vector_iget (v1 , 1 ), 15 ); test_assert_int_equal( int_vector_iget (v1 , 2 ), 20 ); test_assert_int_equal( int_vector_iget (v1 , 3 ), 1 ); test_assert_int_equal( int_vector_iget (v1 , 4 ), 2 ); test_assert_int_equal( int_vector_iget (v1 , 5 ), 3 ); int_vector_free( v1 ); int_vector_free( v2 ); } exit(0); }
int ecl_rft_file_get_well_occurences( const ecl_rft_file_type * rft_file , const char * well) { const int_vector_type * index_vector = hash_get(rft_file->well_index , well); return int_vector_size( index_vector ); }