resdata 6.4.0__cp315-cp315-win_amd64.whl

resdata/.include/ert/geometry/geo_pointset.hpp

@@ -0,0 +1,42 @@
+#ifndef ERT_GEO_POINTSET_H
+#define ERT_GEO_POINTSET_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct geo_pointset_struct geo_pointset_type;
+
+geo_pointset_type *geo_pointset_alloc(bool external_z);
+void geo_pointset_free(geo_pointset_type *pointset);
+void geo_pointset_add_xyz(geo_pointset_type *pointset, double x, double y,
+                          double z);
+int geo_pointset_get_size(const geo_pointset_type *pointset);
+void geo_pointset_iget_xy(const geo_pointset_type *pointset, int index,
+                          double *x, double *y);
+const double *geo_pointset_get_zcoord(const geo_pointset_type *pointset);
+bool geo_pointset_equal(const geo_pointset_type *pointset1,
+                        const geo_pointset_type *pointset2);
+double geo_pointset_iget_z(const geo_pointset_type *pointset, int index);
+void geo_pointset_iset_z(geo_pointset_type *pointset, int index, double value);
+void geo_pointset_memcpy(const geo_pointset_type *src,
+                         geo_pointset_type *target, bool copy_zdata);
+void geo_pointset_shift_z(geo_pointset_type *pointset, double value);
+void geo_pointset_assign_z(geo_pointset_type *pointset, double value);
+void geo_pointset_scale_z(geo_pointset_type *pointset, double value);
+void geo_pointset_imul(geo_pointset_type *pointset,
+                       const geo_pointset_type *other);
+void geo_pointset_iadd(geo_pointset_type *pointset,
+                       const geo_pointset_type *other);
+void geo_pointset_isub(geo_pointset_type *self, const geo_pointset_type *other);
+void geo_pointset_isqrt(geo_pointset_type *pointset);
+
+#ifdef __cplusplus
+}
+#include <memory>
+
+using geo_pointset_ptr =
+    std::unique_ptr<geo_pointset_type, decltype(&geo_pointset_free)>;
+geo_pointset_ptr make_geo_pointset(bool external_z);
+#endif
+#endif

resdata/.include/ert/geometry/geo_polygon.hpp

@@ -0,0 +1,47 @@
+#ifndef ERT_GEO_POLYGON_H
+#define ERT_GEO_POLYGON_H
+
+#include <ert/util/type_macros.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct geo_polygon_struct geo_polygon_type;
+
+geo_polygon_type *geo_polygon_alloc(const char *name);
+void geo_polygon_free(geo_polygon_type *polygon);
+void geo_polygon_free__(void *arg);
+void geo_polygon_add_point(geo_polygon_type *polygon, double x, double y);
+void geo_polygon_add_point_front(geo_polygon_type *polygon, double x, double y);
+geo_polygon_type *geo_polygon_fload_alloc_irap(const char *filename);
+bool geo_polygon_contains_point(const geo_polygon_type *polygon, double x,
+                                double y);
+bool geo_polygon_contains_point__(const geo_polygon_type *polygon, double x,
+                                  double y, bool force_edge_inside);
+void geo_polygon_reset(geo_polygon_type *polygon);
+void geo_polygon_close(geo_polygon_type *polygoon);
+int geo_polygon_get_size(const geo_polygon_type *polygon);
+void geo_polygon_iget_xy(const geo_polygon_type *polygon, int index, double *x,
+                         double *y);
+bool geo_polygon_segment_intersects(const geo_polygon_type *polygon, double x1,
+                                    double y1, double x2, double y2);
+const char *geo_polygon_get_name(const geo_polygon_type *polygon);
+void geo_polygon_set_name(geo_polygon_type *polygon, const char *name);
+double geo_polygon_get_length(geo_polygon_type *polygon);
+bool geo_polygon_equal(const geo_polygon_type *polygon1,
+                       const geo_polygon_type *polygon2);
+
+UTIL_IS_INSTANCE_HEADER(geo_polygon);
+
+#ifdef __cplusplus
+}
+#include <memory>
+#include <string>
+
+using geo_polygon_ptr =
+    std::unique_ptr<geo_polygon_type, decltype(&geo_polygon_free)>;
+
+geo_polygon_ptr make_geo_polygon(std::string name);
+#endif
+#endif

resdata/.include/ert/geometry/geo_polygon_collection.hpp

@@ -0,0 +1,37 @@
+#ifndef ERT_GEO_POLYGON_COLLECTION_H
+#define ERT_GEO_POLYGON_COLLECTION_H
+
+#include <ert/util/type_macros.hpp>
+
+#include <ert/geometry/geo_polygon.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct geo_polygon_collection_struct geo_polygon_collection_type;
+
+geo_polygon_collection_type *geo_polygon_collection_alloc();
+void geo_polygon_collection_free(geo_polygon_collection_type *polygons);
+int geo_polygon_collection_size(const geo_polygon_collection_type *polygons);
+geo_polygon_type *
+geo_polygon_collection_create_polygon(geo_polygon_collection_type *polygons,
+                                      const char *name);
+bool geo_polygon_collection_has_polygon(
+    const geo_polygon_collection_type *polygons, const char *name);
+bool geo_polygon_collection_add_polygon(geo_polygon_collection_type *polygons,
+                                        geo_polygon_type *polygon,
+                                        bool polygon_owner);
+geo_polygon_type *
+geo_polygon_collection_iget_polygon(const geo_polygon_collection_type *polygons,
+                                    int index);
+geo_polygon_type *
+geo_polygon_collection_get_polygon(const geo_polygon_collection_type *polygons,
+                                   const char *polygon_name);
+
+UTIL_IS_INSTANCE_HEADER(geo_polygon_collection);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

resdata/.include/ert/geometry/geo_region.hpp

@@ -0,0 +1,55 @@
+#include <cstdlib>
+
+#include <ert/util/util.hpp>
+#include <ert/util/int_vector.hpp>
+
+#include <ert/geometry/geo_pointset.hpp>
+#include <ert/geometry/geo_polygon.hpp>
+
+#ifndef ERT_GEO_REGION_H
+#define ERT_GEO_REGION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct geo_region_struct geo_region_type;
+
+geo_region_type *geo_region_alloc(const geo_pointset_type *pointset,
+                                  bool preselect);
+void geo_region_free(geo_region_type *region);
+void geo_region_reset(geo_region_type *region);
+const int_vector_type *geo_region_get_index_list(geo_region_type *region);
+
+void geo_region_select_inside_polygon(geo_region_type *region,
+                                      const geo_polygon_type *polygon);
+void geo_region_select_outside_polygon(geo_region_type *region,
+                                       const geo_polygon_type *polygon);
+void geo_region_deselect_inside_polygon(geo_region_type *region,
+                                        const geo_polygon_type *polygon);
+void geo_region_deselect_outside_polygon(geo_region_type *region,
+                                         const geo_polygon_type *polygon);
+
+void geo_region_select_above_line(geo_region_type *region,
+                                  const double xcoords[2],
+                                  const double ycoords[2]);
+void geo_region_select_below_line(geo_region_type *region,
+                                  const double xcoords[2],
+                                  const double ycoords[2]);
+void geo_region_deselect_above_line(geo_region_type *region,
+                                    const double xcoords[2],
+                                    const double ycoords[2]);
+void geo_region_deselect_below_line(geo_region_type *region,
+                                    const double xcoords[2],
+                                    const double ycoords[2]);
+
+#ifdef __cplusplus
+}
+#include <memory>
+
+using geo_region_ptr =
+    std::unique_ptr<geo_region_type, decltype(&geo_region_free)>;
+geo_region_ptr make_geo_region(const geo_pointset_ptr &pointset,
+                               bool preselect);
+#endif
+#endif

resdata/.include/ert/geometry/geo_surface.hpp

@@ -0,0 +1,56 @@
+#ifndef ERT_GEO_SURFACE_H
+#define ERT_GEO_SURFACE_H
+
+#include <ert/geometry/geo_pointset.hpp>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct geo_surface_struct geo_surface_type;
+
+bool geo_surface_equal_header(const geo_surface_type *surface1,
+                              const geo_surface_type *surface2);
+bool geo_surface_equal(const geo_surface_type *surface1,
+                       const geo_surface_type *surface2);
+void geo_surface_free(geo_surface_type *geo_surface);
+geo_pointset_type *geo_surface_get_pointset(const geo_surface_type *surface);
+geo_surface_type *geo_surface_fload_alloc_irap(const char *filename,
+                                               bool loadz);
+geo_surface_type *geo_surface_alloc_new(int nx, int ny, double xinc,
+                                        double yinc, double xstart,
+                                        double ystart, double angle);
+bool geo_surface_fload_irap_zcoord(const geo_surface_type *surface,
+                                   const char *filename, double *zlist);
+double geo_surface_iget_zvalue(const geo_surface_type *surface, int index);
+int geo_surface_get_size(const geo_surface_type *surface);
+void geo_surface_fprintf_irap(const geo_surface_type *surface,
+                              const char *filename);
+int geo_surface_get_nx(const geo_surface_type *surface);
+int geo_surface_get_ny(const geo_surface_type *surface);
+void geo_surface_iget_xy(const geo_surface_type *surface, int index, double *x,
+                         double *y);
+
+void geo_surface_shift(const geo_surface_type *src, double value);
+void geo_surface_scale(const geo_surface_type *src, double value);
+void geo_surface_isub(geo_surface_type *self, const geo_surface_type *other);
+void geo_surface_iset_zvalue(geo_surface_type *surface, int index,
+                             double value);
+void geo_surface_assign_value(const geo_surface_type *src, double value);
+geo_surface_type *geo_surface_alloc_copy(const geo_surface_type *src,
+                                         bool copy_zdata);
+void geo_surface_iadd(geo_surface_type *self, const geo_surface_type *other);
+void geo_surface_imul(geo_surface_type *self, const geo_surface_type *other);
+void geo_surface_isqrt(geo_surface_type *surface);
+
+#ifdef __cplusplus
+}
+#include <memory>
+using geo_surface_ptr =
+    std::unique_ptr<geo_surface_type, decltype(&geo_surface_free)>;
+
+geo_surface_ptr make_geo_surface(int nx, int ny, double xinc, double yinc,
+                                 double xstart, double ystart, double angle);
+
+#endif
+#endif

resdata/.include/ert/geometry/geo_util.hpp

@@ -0,0 +1,28 @@
+#ifndef ERT_GEO_UTIL_H
+#define ERT_GEO_UTIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    GEO_UTIL_LINES_CROSSING = 0,
+    GEO_UTIL_LINES_PARALLELL = 1,
+    GEO_UTIL_LINES_OVERLAPPING = 2,
+    GEO_UTIL_LINES_DEGENERATE = 3,
+    GEO_UTIL_NOT_CROSSING = 4
+} geo_util_xlines_status_enum;
+
+bool geo_util_inside_polygon__(const double *xlist, const double *ylist,
+                               int num_points, double x0, double y0,
+                               bool force_edge_inside);
+geo_util_xlines_status_enum geo_util_xlines(const double **points, double *x0,
+                                            double *y0);
+geo_util_xlines_status_enum geo_util_xsegments(const double **points,
+                                               double *x0, double *y0);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

resdata/.include/ert/util/bool_vector.hpp

@@ -0,0 +1,132 @@
+/*
+   Copyright (C) 2011  Equinor ASA, Norway.
+
+   The file 'vector_template.hpp' is part of ERT - Ensemble based Reservoir Tool.
+
+   ERT is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   ERT is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.
+
+   See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+   for more details.
+*/
+
+#ifndef ERT_bool_VECTOR_H
+#define ERT_bool_VECTOR_H
+#include <memory>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <cstdio>
+
+#include <ert/util/type_macros.hpp>
+#include <ert/util/perm_vector.hpp>
+
+typedef struct bool_vector_struct bool_vector_type;
+typedef bool (bool_ftype) (bool);
+
+
+  int                  bool_vector_lookup_bin( const bool_vector_type * limits , bool value , int guess);
+  int                  bool_vector_lookup_bin__( const bool_vector_type * limits , bool value , int guess);
+  void                 bool_vector_inplace_div( bool_vector_type * vector , const bool_vector_type * inv_factor);
+  void                 bool_vector_inplace_mul( bool_vector_type * vector , const bool_vector_type * factor);
+  void                 bool_vector_inplace_add( bool_vector_type * vector , const bool_vector_type * delta);
+  void                 bool_vector_inplace_sub( bool_vector_type * vector , const bool_vector_type * delta);
+  void                 bool_vector_set_read_only( bool_vector_type * vector , bool read_only);
+  bool                 bool_vector_get_read_only( const bool_vector_type * vector );
+  void                 bool_vector_memcpy_data( bool * target, const bool_vector_type * src );
+  void                 bool_vector_memcpy_from_data( bool_vector_type * target , const bool * src , int src_size );
+  void                 bool_vector_memcpy(  bool_vector_type * target , const bool_vector_type * src);
+  void                 bool_vector_memcpy_data_block( bool_vector_type * target , const bool_vector_type * src , int target_offset , int src_offset , int len);
+  bool                 bool_vector_growable( const bool_vector_type * vector);
+  void                 bool_vector_select_unique(bool_vector_type * vector);
+  bool_vector_type * bool_vector_alloc( int init_size , bool );
+  bool_vector_type * bool_vector_alloc_private_wrapper(int init_size, bool default_value , bool * data , int alloc_size);
+  bool_vector_type * bool_vector_alloc_shared_wrapper(int init_size, bool default_value , bool * data , int alloc_size);
+  bool_vector_type * bool_vector_alloc_strided_copy( const bool_vector_type * src , int start , int stop , int stride );
+  bool_vector_type * bool_vector_alloc_copy( const bool_vector_type * src);
+  void                 bool_vector_imul(bool_vector_type * vector, int index, bool factor);
+  void                 bool_vector_scale(bool_vector_type * vector, bool factor);
+  void                 bool_vector_div(bool_vector_type * vector, bool divisor);
+  bool               bool_vector_reverse_iget(const bool_vector_type * vector , int index);
+  bool               bool_vector_iget(const bool_vector_type * , int);
+  bool               bool_vector_safe_iget(const bool_vector_type * , int);
+  bool               bool_vector_get_min(const bool_vector_type * vector);
+  bool               bool_vector_get_max(const bool_vector_type * vector);
+  int                  bool_vector_get_min_index(const bool_vector_type * vector, bool reverse);
+  int                  bool_vector_get_max_index(const bool_vector_type * vector, bool reverse);
+  bool               bool_vector_iadd( bool_vector_type * vector , int index , bool delta);
+  void                 bool_vector_resize( bool_vector_type * vector , int new_size , bool default_value );
+  void                 bool_vector_iset(bool_vector_type *       , int , bool);
+  void                 bool_vector_iset_block(bool_vector_type * vector , int index , int block_size , bool value);
+  void                 bool_vector_idel_block( bool_vector_type * vector , int index , int block_size);
+  bool               bool_vector_idel( bool_vector_type * vector , int index);
+  bool               bool_vector_del_value( bool_vector_type * vector , bool del_value);
+  void                 bool_vector_insert( bool_vector_type * vector , int index , bool value);
+  void                 bool_vector_append(bool_vector_type *     , bool);
+  void                 bool_vector_free_container(bool_vector_type * vector);
+  void                 bool_vector_free(bool_vector_type *);
+  void                 bool_vector_free__(void *);
+  void                 bool_vector_free_data(bool_vector_type *);
+  void                 bool_vector_reset(bool_vector_type *);
+  void                 bool_vector_reset__(void * __vector);
+  int                  bool_vector_size(const bool_vector_type * );
+  void                 bool_vector_lshift(bool_vector_type * vector , int shift);
+  void                 bool_vector_rshift(bool_vector_type * vector , int shift);
+  bool               bool_vector_pop(bool_vector_type * vector);
+  bool               bool_vector_get_first(const bool_vector_type * vector);
+  bool               bool_vector_get_last(const bool_vector_type * );
+  bool *             bool_vector_get_ptr(const bool_vector_type * );
+  bool *             bool_vector_alloc_data_copy( const bool_vector_type * vector );
+  const bool *       bool_vector_get_const_ptr(const bool_vector_type * );
+  bool bool_vector_init_linear(bool_vector_type * vector , bool start_value, bool end_value, int num_values);
+  void                 bool_vector_init_range(bool_vector_type * vector , bool value1 , bool value2 , bool delta);
+  void                 bool_vector_set_many(bool_vector_type *  , int  , const bool *  , int );
+  void                 bool_vector_set_all(bool_vector_type * vector , bool value);
+  void                 bool_vector_append_many(bool_vector_type * vector , const bool * data , int length);
+  void                 bool_vector_append_vector(bool_vector_type * vector , const bool_vector_type * other);
+  void                 bool_vector_shrink(bool_vector_type * );
+  bool               bool_vector_sum(const bool_vector_type * );
+  bool               bool_vector_get_default(const bool_vector_type * );
+  void                 bool_vector_set_default(bool_vector_type * vector, bool default_value);
+  void                 bool_vector_append_default(bool_vector_type * vector , bool default_value);
+  void                 bool_vector_iset_default(bool_vector_type * vector , int index , bool default_value);
+  bool                 bool_vector_is_sorted( const bool_vector_type * vector , bool reverse);
+  bool                 bool_vector_contains(const bool_vector_type * vector , bool value);
+  bool                 bool_vector_contains_sorted(const bool_vector_type * vector , bool value);
+  int                  bool_vector_index(const bool_vector_type * vector , bool value);
+  int                  bool_vector_index_sorted(const bool_vector_type * vector , bool value);
+  void                 bool_vector_sort(bool_vector_type * vector);
+  void                 bool_vector_rsort(bool_vector_type * vector);
+  void                 bool_vector_permute(bool_vector_type * vector , const perm_vector_type * perm);
+  perm_vector_type *   bool_vector_alloc_sort_perm(const bool_vector_type * vector);
+  perm_vector_type *   bool_vector_alloc_rsort_perm(const bool_vector_type * vector);
+  void                 bool_vector_fprintf(const bool_vector_type * vector , FILE * stream , const char * name , const char * fmt);
+  void                 bool_vector_fwrite(const bool_vector_type * vector , FILE * stream);
+  bool_vector_type * bool_vector_fread_alloc( FILE * stream );
+  void                 bool_vector_fread( bool_vector_type * vector , FILE * stream );
+  void                 bool_vector_fwrite_data( const bool_vector_type * vector , FILE * stream );
+  void                 bool_vector_fread_data( bool_vector_type * vector , int size, FILE * stream);
+  bool                 bool_vector_equal(const bool_vector_type * vector1 , const bool_vector_type * vector2);
+  int                  bool_vector_first_equal(const bool_vector_type * vector1, const bool_vector_type * vector2, int offset);
+  int                  bool_vector_first_not_equal(const bool_vector_type * vector1, const bool_vector_type * vector2, int offset);
+  void                 bool_vector_apply(bool_vector_type * vector , bool_ftype *func);
+  int                  bool_vector_count_equal( const bool_vector_type * vector , bool cmp_value);
+  int                  bool_vector_element_size( const bool_vector_type * vector );
+  void                 bool_vector_range_fill(bool_vector_type * vector , bool limit1 , bool delta , bool limit2);
+  void                 bool_vector_shift(bool_vector_type * vector, bool delta);
+
+  UTIL_SAFE_CAST_HEADER( bool_vector );
+  UTIL_IS_INSTANCE_HEADER( bool_vector );
+
+#ifdef __cplusplus
+}
+#endif
+std::unique_ptr<bool_vector_type, decltype(&bool_vector_free)> make_bool_vector(int, bool);
+#endif
+//

resdata/.include/ert/util/build_config.hpp

@@ -0,0 +1,50 @@
+/* #undef HAVE_GMTIME_R */
+/* #undef HAVE_TIMEGM */
+/* #undef HAVE_LOCALTIME_R */
+/* #undef HAVE_REALPATH */
+/* #undef HAVE__USLEEP */
+/* #undef HAVE_FNMATCH */
+/* #undef HAVE_FTRUNCATE */
+#define HAVE_POSIX_CHDIR
+#define HAVE_WINDOWS_CHDIR
+#define HAVE_POSIX_GETCWD
+#define HAVE_WINDOWS_GETCWD
+/* #undef HAVE_TZNAME */
+#define HAVE_ROUND
+#define HAVE_VA_COPY
+/* #undef HAVE_SIGBUS */
+/* #undef HAVE_PTHREAD */
+/* #undef HAVE_PID_T */
+/* #undef HAVE_EXECINFO */
+/* #undef HAVE_FORK */
+#define HAVE_POSIX_MKDIR
+#define HAVE_WINDOWS_MKDIR
+/* #undef HAVE_GETPWUID */
+/* #undef HAVE_FSYNC */
+#define HAVE_CHMOD
+/* #undef HAVE_MODE_T */
+#define HAVE_CXX_SHARED_PTR
+#define HAVE_POSIX_UNLINK
+#define HAVE_WINDOWS_UNLINK
+/* #undef HAVE_SIGHANDLER_T */
+
+#define HAVE_POSIX_ACCESS
+#define HAVE_WINDOWS__ACCESS
+/* #undef HAVE_WINDOWS_GET_TEMP_PATH */
+#define HAVE_WINDOWS_TZNAME
+
+#ifdef HAVE_VA_COPY
+#define UTIL_VA_COPY(target,src) va_copy(target,src)
+#else
+#define UTIL_VA_COPY(target,src) target = src
+#endif
+
+#ifdef HAVE_FORK
+#ifdef HAVE_PTHREAD
+#ifdef HAVE_EXECINFO
+#ifdef HAVE_GETPWUID
+
+#endif
+#endif
+#endif
+#endif

resdata/.include/ert/util/double_vector.hpp

@@ -0,0 +1,132 @@
+/*
+   Copyright (C) 2011  Equinor ASA, Norway.
+
+   The file 'vector_template.hpp' is part of ERT - Ensemble based Reservoir Tool.
+
+   ERT is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   ERT is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.
+
+   See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+   for more details.
+*/
+
+#ifndef ERT_double_VECTOR_H
+#define ERT_double_VECTOR_H
+#include <memory>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <cstdio>
+
+#include <ert/util/type_macros.hpp>
+#include <ert/util/perm_vector.hpp>
+
+typedef struct double_vector_struct double_vector_type;
+typedef double (double_ftype) (double);
+
+
+  int                  double_vector_lookup_bin( const double_vector_type * limits , double value , int guess);
+  int                  double_vector_lookup_bin__( const double_vector_type * limits , double value , int guess);
+  void                 double_vector_inplace_div( double_vector_type * vector , const double_vector_type * inv_factor);
+  void                 double_vector_inplace_mul( double_vector_type * vector , const double_vector_type * factor);
+  void                 double_vector_inplace_add( double_vector_type * vector , const double_vector_type * delta);
+  void                 double_vector_inplace_sub( double_vector_type * vector , const double_vector_type * delta);
+  void                 double_vector_set_read_only( double_vector_type * vector , bool read_only);
+  bool                 double_vector_get_read_only( const double_vector_type * vector );
+  void                 double_vector_memcpy_data( double * target, const double_vector_type * src );
+  void                 double_vector_memcpy_from_data( double_vector_type * target , const double * src , int src_size );
+  void                 double_vector_memcpy(  double_vector_type * target , const double_vector_type * src);
+  void                 double_vector_memcpy_data_block( double_vector_type * target , const double_vector_type * src , int target_offset , int src_offset , int len);
+  bool                 double_vector_growable( const double_vector_type * vector);
+  void                 double_vector_select_unique(double_vector_type * vector);
+  double_vector_type * double_vector_alloc( int init_size , double );
+  double_vector_type * double_vector_alloc_private_wrapper(int init_size, double default_value , double * data , int alloc_size);
+  double_vector_type * double_vector_alloc_shared_wrapper(int init_size, double default_value , double * data , int alloc_size);
+  double_vector_type * double_vector_alloc_strided_copy( const double_vector_type * src , int start , int stop , int stride );
+  double_vector_type * double_vector_alloc_copy( const double_vector_type * src);
+  void                 double_vector_imul(double_vector_type * vector, int index, double factor);
+  void                 double_vector_scale(double_vector_type * vector, double factor);
+  void                 double_vector_div(double_vector_type * vector, double divisor);
+  double               double_vector_reverse_iget(const double_vector_type * vector , int index);
+  double               double_vector_iget(const double_vector_type * , int);
+  double               double_vector_safe_iget(const double_vector_type * , int);
+  double               double_vector_get_min(const double_vector_type * vector);
+  double               double_vector_get_max(const double_vector_type * vector);
+  int                  double_vector_get_min_index(const double_vector_type * vector, bool reverse);
+  int                  double_vector_get_max_index(const double_vector_type * vector, bool reverse);
+  double               double_vector_iadd( double_vector_type * vector , int index , double delta);
+  void                 double_vector_resize( double_vector_type * vector , int new_size , double default_value );
+  void                 double_vector_iset(double_vector_type *       , int , double);
+  void                 double_vector_iset_block(double_vector_type * vector , int index , int block_size , double value);
+  void                 double_vector_idel_block( double_vector_type * vector , int index , int block_size);
+  double               double_vector_idel( double_vector_type * vector , int index);
+  double               double_vector_del_value( double_vector_type * vector , double del_value);
+  void                 double_vector_insert( double_vector_type * vector , int index , double value);
+  void                 double_vector_append(double_vector_type *     , double);
+  void                 double_vector_free_container(double_vector_type * vector);
+  void                 double_vector_free(double_vector_type *);
+  void                 double_vector_free__(void *);
+  void                 double_vector_free_data(double_vector_type *);
+  void                 double_vector_reset(double_vector_type *);
+  void                 double_vector_reset__(void * __vector);
+  int                  double_vector_size(const double_vector_type * );
+  void                 double_vector_lshift(double_vector_type * vector , int shift);
+  void                 double_vector_rshift(double_vector_type * vector , int shift);
+  double               double_vector_pop(double_vector_type * vector);
+  double               double_vector_get_first(const double_vector_type * vector);
+  double               double_vector_get_last(const double_vector_type * );
+  double *             double_vector_get_ptr(const double_vector_type * );
+  double *             double_vector_alloc_data_copy( const double_vector_type * vector );
+  const double *       double_vector_get_const_ptr(const double_vector_type * );
+  bool double_vector_init_linear(double_vector_type * vector , double start_value, double end_value, int num_values);
+  void                 double_vector_init_range(double_vector_type * vector , double value1 , double value2 , double delta);
+  void                 double_vector_set_many(double_vector_type *  , int  , const double *  , int );
+  void                 double_vector_set_all(double_vector_type * vector , double value);
+  void                 double_vector_append_many(double_vector_type * vector , const double * data , int length);
+  void                 double_vector_append_vector(double_vector_type * vector , const double_vector_type * other);
+  void                 double_vector_shrink(double_vector_type * );
+  double               double_vector_sum(const double_vector_type * );
+  double               double_vector_get_default(const double_vector_type * );
+  void                 double_vector_set_default(double_vector_type * vector, double default_value);
+  void                 double_vector_append_default(double_vector_type * vector , double default_value);
+  void                 double_vector_iset_default(double_vector_type * vector , int index , double default_value);
+  bool                 double_vector_is_sorted( const double_vector_type * vector , bool reverse);
+  bool                 double_vector_contains(const double_vector_type * vector , double value);
+  bool                 double_vector_contains_sorted(const double_vector_type * vector , double value);
+  int                  double_vector_index(const double_vector_type * vector , double value);
+  int                  double_vector_index_sorted(const double_vector_type * vector , double value);
+  void                 double_vector_sort(double_vector_type * vector);
+  void                 double_vector_rsort(double_vector_type * vector);
+  void                 double_vector_permute(double_vector_type * vector , const perm_vector_type * perm);
+  perm_vector_type *   double_vector_alloc_sort_perm(const double_vector_type * vector);
+  perm_vector_type *   double_vector_alloc_rsort_perm(const double_vector_type * vector);
+  void                 double_vector_fprintf(const double_vector_type * vector , FILE * stream , const char * name , const char * fmt);
+  void                 double_vector_fwrite(const double_vector_type * vector , FILE * stream);
+  double_vector_type * double_vector_fread_alloc( FILE * stream );
+  void                 double_vector_fread( double_vector_type * vector , FILE * stream );
+  void                 double_vector_fwrite_data( const double_vector_type * vector , FILE * stream );
+  void                 double_vector_fread_data( double_vector_type * vector , int size, FILE * stream);
+  bool                 double_vector_equal(const double_vector_type * vector1 , const double_vector_type * vector2);
+  int                  double_vector_first_equal(const double_vector_type * vector1, const double_vector_type * vector2, int offset);
+  int                  double_vector_first_not_equal(const double_vector_type * vector1, const double_vector_type * vector2, int offset);
+  void                 double_vector_apply(double_vector_type * vector , double_ftype *func);
+  int                  double_vector_count_equal( const double_vector_type * vector , double cmp_value);
+  int                  double_vector_element_size( const double_vector_type * vector );
+  void                 double_vector_range_fill(double_vector_type * vector , double limit1 , double delta , double limit2);
+  void                 double_vector_shift(double_vector_type * vector, double delta);
+
+  UTIL_SAFE_CAST_HEADER( double_vector );
+  UTIL_IS_INSTANCE_HEADER( double_vector );
+
+#ifdef __cplusplus
+}
+#endif
+std::unique_ptr<double_vector_type, decltype(&double_vector_free)> make_double_vector(int, double);
+#endif
+//

resdata/.include/ert/util/ert_api_config.hpp

@@ -0,0 +1,15 @@
+#define ERT_HAVE_ISFINITE
+/* #undef ERT_HAVE_GETOPT */
+/* #undef ERT_HAVE_UNISTD */
+/* #undef ERT_HAVE_SPAWN */
+/* #undef ERT_HAVE_OPENDIR */
+/* #undef ERT_HAVE_SYMLINK */
+/* #undef ERT_HAVE_READLINKAT */
+/* #undef ERT_HAVE_READLINKAT_DECLARATION */
+/* #undef ERT_HAVE_GLOB */
+/* #undef ERT_HAVE_GETUID */
+/* #undef ERT_HAVE_REGEXP */
+/* #undef ERT_TIME_T_64BIT_ACCEPT_PRE1970 */
+#define ERT_WINDOWS_LFS
+/* #undef ERT_HAVE_PING */
+/* #undef PING_CMD */

resdata/.include/ert/util/ert_unique_ptr.hpp

@@ -0,0 +1,17 @@
+#ifndef ERT_UNIQUE_PTR
+#define ERT_UNIQUE_PTR
+
+#include <memory>
+
+namespace ERT {
+
+template <typename T, void (*F)(T *)> struct deleter {
+    void operator()(T *arg) const { F(arg); }
+};
+
+template <typename T, void (*F)(T *)>
+using ert_unique_ptr = std::unique_ptr<T, deleter<T, F>>;
+
+} // namespace ERT
+
+#endif