interp_method_dnn.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifdef HAVE_CONFIG_H
// Get the definition of the 'restrict' keyword.
#include "config.h"
#endif
 
#include <limits.h>
#include <string.h>
#include <float.h>
 
#include "interpolation/methods/interp_method_internal.h"
#include "interpolation/methods/interp_method_config_internal.h"
#include "interpolation/methods/interp_method_dnn.h"
#include "interpolation/methods/interp_method_utils.h"
#include "parameter/param_distance.h"
#include "parameter/param_enum.h"
#include "parameter/param_dble.h"
#include "parameter/param_int.h"
#include "parameter/param_internal.h"
#include "parameter/param_oneof.h"
#include "parameter/param_struct.h"
#include "area.h"
#include "instrument_internal.h"
#include "yac_mpi_common.h"
 
static size_t do_search_dnn(struct interp_method * method,
                            struct yac_interp_grid * interp_grid,
                            size_t * tgt_points, size_t count,
                            struct yac_interp_weights * weights,
                            int * interpolation_complete);
static void delete_dnn(struct interp_method * method);
 
static struct interp_method_vtable
  interp_method_dnn_vtable = {
    .do_search = do_search_dnn,
    .delete = delete_dnn};
 
struct interp_method_dnn {
 
  struct interp_method_vtable * vtable;
  yac_interp_compute_weights_func compute_weights;
  enum yac_interp_dnn_search_distance_type search_distance_type;
  union {
    double fixed;
    double scale;
  } search_distance;
  size_t n_min;
  double scale;
};
 
static struct yac_interp_method_dnn_config_search_distance *
copy_search_distance_config(
  struct yac_interp_method_dnn_config_search_distance const *search_distance) {
 
  struct yac_interp_method_dnn_config_search_distance *copy = NULL;
  if (search_distance != NULL) {
    copy = xmalloc(sizeof(*copy));
    *copy = *search_distance;
  }
  return copy;
}
 
static struct yac_interp_method_dnn_config_search_distance
  get_default_search_distance(void) {
 
  YAC_ASSERT(
    YAC_INTERP_DNN_SEARCH_DISTANCE_TYPE_DEFAULT ==
    YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA,
    "internal error (default search distance type is assumed to be cell area)");
 
  return
    (struct yac_interp_method_dnn_config_search_distance){
      .type = YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA,
      .search_distance.scale =
        YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA_DEFAULT};
}
 
static void set_dnn_bounding_circles(
  struct interp_method_dnn * method_dnn, struct yac_interp_grid * interp_grid,
  size_t * tgt_points, yac_coordinate_pointer tgt_coords,
  struct bounding_circle * bnd_circles, size_t count) {
 
  switch(method_dnn->search_distance_type) {
 
    YAC_UNREACHABLE_DEFAULT("invalid search distance type");
 
    case (YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED): {
 
      // use a fixed search distance for all target points
      double search_distance = method_dnn->search_distance.fixed;
      struct sin_cos_angle search_distance_angle =
        sin_cos_angle_new(sin(search_distance), cos(search_distance));
      for (size_t i = 0; i < count; ++i) {
        memcpy(bnd_circles[i].base_vector, tgt_coords[i], 3 * sizeof(double));
        bnd_circles[i].inc_angle = search_distance_angle;
        bnd_circles[i].sq_crd = DBL_MAX;
      }
      break;
 
    }
    case (YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA): {
 
      // compute search distance from target cell area
      // area of spherical cap: A = 2*PI*(1 - cos(theta))
      // using half-angle identity: 1 - cos(theta) = 2*sin²(theta/2)
      // => sin(theta/2) = sqrt(A/(4*PI))
      // => theta = 2 * arcsin(sqrt(A/(4*PI)))
      double search_distance_scale = method_dnn->search_distance.scale;
      struct yac_const_basic_grid_data * tgt_basic_grid_data =
        yac_interp_grid_get_basic_grid_data_tgt(interp_grid);
 
      // allocate buffer for grid cell
      struct yac_grid_cell grid_cell;
      yac_init_grid_cell(&grid_cell);
 
      for (size_t i = 0; i < count; ++i) {
 
        // get target cell
        yac_const_basic_grid_data_get_grid_cell(
          tgt_basic_grid_data, tgt_points[i], &grid_cell);
 
        // compute cell area
        double cell_area = yac_grid_cell_area(grid_cell);
 
        // convert area to polar angle of equivalent spherical cap
        // theta = 2 * arcsin(sqrt(A/(4*PI)))
        double sin_arg = sqrt(cell_area / (4.0 * M_PI));
        // clamp to valid range [0, 1] for numerical safety
        if (sin_arg > 1.0) sin_arg = 1.0;
        double theta = 2.0 * asin(sin_arg);
 
        // apply scale factor and clamp to [0, PI]
        double search_distance = theta * search_distance_scale;
        if (search_distance > M_PI) search_distance = M_PI;
        if (search_distance < yac_angle_tol) search_distance = yac_angle_tol;
 
        memcpy(bnd_circles[i].base_vector, tgt_coords[i], 3 * sizeof(double));
        bnd_circles[i].inc_angle =
          sin_cos_angle_new(sin(search_distance), cos(search_distance));
        bnd_circles[i].sq_crd = DBL_MAX;
      }
 
      yac_free_grid_cell(&grid_cell);
      break;
    }
  }
}
 
static size_t do_search_dnn(struct interp_method * method,
                            struct yac_interp_grid * interp_grid,
                            size_t * tgt_points, size_t count,
                            struct yac_interp_weights * weights,
                            int * interpolation_complete) {
 
  if (*interpolation_complete) return 0;
 
  YAC_INSTRUMENT_START(YAC_INSTR_INTERP_SEARCH_DNN);
 
  struct interp_method_dnn * method_dnn = (struct interp_method_dnn *)method;
 
  CHECK_SRC_FIELD_COUNT_SINGLE(interp_grid)
 
  YAC_INTERP_GRID_FIELD_ASSERT(
    interp_grid,
    (method_dnn->search_distance_type != YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA) ||
    (yac_interp_grid_get_tgt_field_location(interp_grid) == YAC_LOC_CELL),
    "search_distance_type == cell_area requires target_field_location == CELL")
 
  // get coordinates of target points
  yac_coordinate_pointer tgt_coords = xmalloc(count * sizeof(*tgt_coords));
  yac_interp_grid_get_tgt_coordinates(
    interp_grid, tgt_points, count, tgt_coords);
 
  // create bounding circles for each target point
  struct bounding_circle * bnd_circles =
    xmalloc(count * sizeof(*bnd_circles));
 
  // determine the bounding cicles for each target
  set_dnn_bounding_circles(
    method_dnn, interp_grid, tgt_points, tgt_coords, bnd_circles, count);
 
  // search for source points within the bounding circles
  size_t * src_points = NULL;
  size_t * num_src_per_tgt = xmalloc(count * sizeof(*num_src_per_tgt));
  int const src_field_idx = 0;
  yac_interp_grid_do_dnn_search_src(
    interp_grid, bnd_circles, count, src_field_idx, &src_points,
    num_src_per_tgt);
 
  free(bnd_circles);
 
  // process results of yac_interp_grid_do_dnn_search_src
  // * determine which target points have enough (>= n_min) source points
  // * compute maximum number of source points per target
  // * compute prefix sums for src_points offsets
  // * compute total number of weights needed
  size_t result_count = 0;
  size_t * reorder_idx = xmalloc(count * sizeof(*reorder_idx));
  int * fail_flag = xmalloc(count * sizeof(*fail_flag));
  size_t max_src_per_tgt = 0;
  size_t * src_offsets = xmalloc(count * sizeof(*src_offsets));
  size_t src_offset = 0;
  size_t total_weights = 0;
  size_t n_min = method_dnn->n_min;
  for (size_t i = 0; i < count; ++i) {
    src_offsets[i] = src_offset;
    size_t curr_num_src_per_tgt = num_src_per_tgt[i];
    src_offset += curr_num_src_per_tgt;
    if (curr_num_src_per_tgt < n_min) {
      fail_flag[i] = 1;
    } else {
      fail_flag[i] = 0;
      result_count++;
      if (curr_num_src_per_tgt > max_src_per_tgt) {
        max_src_per_tgt = curr_num_src_per_tgt;
      }
      total_weights += curr_num_src_per_tgt;
    }
    reorder_idx[i] = i;
  }
 
  // sort target points, for which the search was successful to the beginning
  // of tgt_points
  yac_quicksort_index_int_size_t_size_t(
    fail_flag, count, reorder_idx, tgt_points);
  free(fail_flag);
 
  // compute weights for successful target points
  yac_interp_compute_weights_func compute_weights_func =
    method_dnn->compute_weights;
  double scale = method_dnn->scale;
 
  double * w = xmalloc(total_weights * sizeof(*w));
  size_t * num_weights_per_tgt =
    xmalloc(result_count * sizeof(*num_weights_per_tgt));
  size_t * reordered_src_points =
    xmalloc(total_weights * sizeof(*reordered_src_points));
 
  // temporary buffer for source coordinates
  yac_coordinate_pointer src_coord_buffer =
    xmalloc(max_src_per_tgt * sizeof(*src_coord_buffer));
 
  // get source field coordinates for weight computation
  yac_const_coordinate_pointer src_field_coordinates =
    yac_interp_grid_get_src_field_coords(interp_grid, src_field_idx);
 
  for (size_t i = 0, weight_offset = 0; i < result_count; ++i) {
    size_t curr_reorder_idx = reorder_idx[i];
    size_t curr_num_src_per_tgt = num_src_per_tgt[curr_reorder_idx];
    size_t curr_src_offset = src_offsets[curr_reorder_idx];
 
    // copy source coordinates
    for (size_t j = 0; j < curr_num_src_per_tgt; ++j) {
      memcpy(
        src_coord_buffer[j],
        src_field_coordinates[src_points[curr_src_offset + j]],
        3 * sizeof(double));
    }
    memcpy(
      reordered_src_points + weight_offset, src_points + curr_src_offset,
      curr_num_src_per_tgt * sizeof(*reordered_src_points));
    num_weights_per_tgt[i] = curr_num_src_per_tgt;
 
    // compute weights
    compute_weights_func(
      tgt_coords[curr_reorder_idx],
      (yac_const_coordinate_pointer)src_coord_buffer, curr_num_src_per_tgt,
      w + weight_offset, scale);
 
    weight_offset += curr_num_src_per_tgt;
  }
 
  free(src_offsets);
  free(src_coord_buffer);
  free(src_points);
  free(num_src_per_tgt);
  free(tgt_coords);
 
  // get remote point information
  struct remote_point * srcs =
    yac_interp_grid_get_src_remote_points(
      interp_grid, src_field_idx, reordered_src_points, total_weights);
 
  struct remote_points tgts = {
    .data =
      yac_interp_grid_get_tgt_remote_points(
        interp_grid, tgt_points, result_count),
    .count = result_count};
 
  // store weights
  yac_interp_weights_add_wsum(
    weights, &tgts, num_weights_per_tgt, srcs, w);
 
  free(reorder_idx);
  free(reordered_src_points);
  free(tgts.data);
  free(srcs);
  free(w);
  free(num_weights_per_tgt);
 
  YAC_INSTRUMENT_STOP(YAC_INSTR_INTERP_SEARCH_DNN);
 
  return result_count;
}
 
struct interp_method * yac_interp_method_dnn_new(
  struct yac_interp_method_dnn_config config) {
 
  struct interp_method_dnn * method = xmalloc(1 * sizeof(*method));
 
  YAC_ASSERT(
    config.search_distance != NULL, "search_distance config is NULL")
 
  YAC_ASSERT_F(
    config.n_min >= 1,
    "unsupported value for n_min (%d), has to be >= 1", config.n_min)
 
  method->vtable = &interp_method_dnn_vtable;
  method->search_distance_type = config.search_distance->type;
  method->n_min = (size_t)config.n_min;
 
  switch (config.search_distance->type) {
    YAC_UNREACHABLE_DEFAULT("unsupported search distance type");
    case (YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED): {
 
    YAC_ASSERT_F(
      (config.search_distance->search_distance.fixed > 0.0) &&
      (config.search_distance->search_distance.fixed <= M_PI),
      "unsupported value for search_distance (%lf), has to be in (0.0,PI]",
      config.search_distance->search_distance.fixed)
    method->search_distance.fixed =
      config.search_distance->search_distance.fixed;
    break;
    }
    case (YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA): {
 
      YAC_ASSERT_F(
        config.search_distance->search_distance.scale > 0.0,
        "search_distance_scale must be positive (%lf)",
        config.search_distance->search_distance.scale)
      method->search_distance.scale =
        config.search_distance->search_distance.scale;
    }
  }
 
  switch (config.type) {
    YAC_UNREACHABLE_DEFAULT("unsupported weighting type");
    case(YAC_INTERP_DNN_WEIGHT_AVG): {
      method->scale = YAC_INTERP_DNN_DUMMY_SCALE;
      method->compute_weights = yac_interp_compute_weights_avg;
      break;
    }
    case(YAC_INTERP_DNN_WEIGHT_DIST): {
      method->scale = YAC_INTERP_DNN_DUMMY_SCALE;
      method->compute_weights = yac_interp_compute_weights_dist;
      break;
    }
    case(YAC_INTERP_DNN_WEIGHT_GAUSS): {
      YAC_ASSERT_F(
        config.gauss_scale > 0.0,
        "gauss_scale must be positive (%lf)", config.gauss_scale)
      method->scale = config.gauss_scale;
      method->compute_weights = yac_interp_compute_weights_gauss;
      break;
    }
    case(YAC_INTERP_DNN_WEIGHT_RBF): {
      YAC_ASSERT_F(
        config.rbf_scale > 0.0,
        "rbf_scale must be positive (%lf)", config.rbf_scale)
      method->scale = config.rbf_scale;
      method->compute_weights = yac_interp_compute_weights_rbf;
      break;
    }
  };
 
  return (struct interp_method*)method;
}
 
static void delete_dnn(struct interp_method * method) {
  free(method);
}
 
// --- Modular config struct and vtable for DNN method ---
 
struct yac_interp_method_config_dnn {
  struct yac_interp_method_config base;
  struct yac_interp_method_dnn_config config;
};
 
static void config_dnn_delete(
  struct yac_interp_method_config *config) {
  struct yac_interp_method_config_dnn *config_dnn =
    (struct yac_interp_method_config_dnn *)config;
  free(config_dnn->config.search_distance);
  free(config_dnn);
}
 
static struct yac_interp_method_config * config_dnn_copy(
  const struct yac_interp_method_config *config) {
  DEF_INTERP_METHOD_CONFIG_TYPE(dnn)
  struct yac_interp_method_config_dnn *copy =
    xmalloc(sizeof(*copy));
  copy->base.vtable = config_dnn->base.vtable;
  copy->base.root_param_cache = NULL;
  copy->config = config_dnn->config;
  copy->config.search_distance =
    copy_search_distance_config(config_dnn->config.search_distance);
  return (struct yac_interp_method_config *)copy;
}
 
static int config_dnn_compare(
  void const *a_, void const *b_) {
  DEF_INTERP_METHOD_CONFIG_COMPARE_TYPE(dnn)
 
  struct yac_interp_method_config_dnn a_cmp = *a;
  struct yac_interp_method_config_dnn b_cmp = *b;
  struct yac_interp_method_dnn_config_search_distance default_search_distance =
    get_default_search_distance();
 
  if (a_cmp.config.search_distance == NULL)
    a_cmp.config.search_distance = &default_search_distance;
  if (b_cmp.config.search_distance == NULL)
    b_cmp.config.search_distance = &default_search_distance;
 
  a = &a_cmp;
  b = &b_cmp;
 
  // Compare distance-based nearest neighbor interpolation options:
  // 1. Weighting type (AVG, DIST, GAUSS, RBF, ...)
  CHECK_ENUM(config.type);
  // 2. Search distance type (fixed or cell-area scaled)
  CHECK_ENUM(config.search_distance->type);
  // 3. Minimum number of source points required per target point
  CHECK_INT(config.n_min);
  // 4. Compare search distance value (fixed or scale, with tolerance)
  switch (a->config.search_distance->type) {
    YAC_UNREACHABLE_DEFAULT(
      "invalid distance-nearest-neighbour search distance type");
    case YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED:
      CHECK_ANGLE(config.search_distance->search_distance.fixed);
      break;
    case YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA:
      CHECK_ANGLE(config.search_distance->search_distance.scale);
      break;
  }
  // 5. Compare scale parameter for GAUSS/RBF types
  switch (a->config.type) {
    YAC_UNREACHABLE_DEFAULT(
      "invalid distance-nearest-neighbour search distance type");
    case YAC_INTERP_DNN_WEIGHT_GAUSS:
      CHECK_DOUBLE(config.gauss_scale);
      break;
    case YAC_INTERP_DNN_WEIGHT_RBF:
      CHECK_DOUBLE(config.rbf_scale);
      break;
    case YAC_INTERP_DNN_WEIGHT_AVG: {__attribute__((fallthrough));}
    case YAC_INTERP_DNN_WEIGHT_DIST:
      // nothing to compare
      break;
  }
  return 0;
}
 
// Gets interpolation method typed_config_hcsbb_get_type
static enum yac_interpolation_list config_dnn_get_type() {
  return YAC_DISTANCE_NEAREST_NEIGHBOR;
}
 
static struct interp_method * config_dnn_generate(
  struct yac_interp_method_config const *config) {
  const struct yac_interp_method_config_dnn *config_dnn =
    (const struct yac_interp_method_config_dnn *)config;
  struct yac_interp_method_dnn_config method_config = config_dnn->config;
  struct yac_interp_method_dnn_config_search_distance default_search_distance =
    get_default_search_distance();
 
  if (method_config.search_distance == NULL) {
    method_config.search_distance = &default_search_distance;
  }
 
  return yac_interp_method_dnn_new(method_config);
}
 
static struct yac_param *
  yac_interp_method_dnn_config_search_distance_build_param(
    struct yac_interp_method_dnn_config_search_distance *search_distance) {
 
  if (search_distance == NULL) {
    return NULL;
  }
 
  enum {
    FIXED_HAS_DEFAULT = 1,
    FIXED_IS_DEFINED = 1,
    CELL_AREA_HAS_DEFAULT = 1,
    CELL_AREA_IS_DEFINED = 1,
    SCALE_ALLOW_NAN = 0,
    SCALE_ALLOW_INF = 0,
  };
 
  YAC_ASSERT(search_distance != NULL, "search_distance is NULL")
 
  struct yac_param * param = NULL;
 
  switch (search_distance->type) {
    YAC_UNREACHABLE_DEFAULT("invalid search distance type");
    case YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED:
      param =
        yac_param_distance_new(
          "fixed",
          &search_distance->search_distance.fixed,
          YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED_DEFAULT,
          0.0, M_PI - 0.000001,
          FIXED_HAS_DEFAULT, FIXED_IS_DEFINED);
      break;
    case YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA:
      param =
        yac_param_dble_new(
          "cell_area",
          &search_distance->search_distance.scale,
          YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA_DEFAULT,
          0.0, DBL_MAX,
          SCALE_ALLOW_NAN, SCALE_ALLOW_INF,
          CELL_AREA_HAS_DEFAULT, CELL_AREA_IS_DEFINED);
      break;
  }
 
  return param;
}
 
static int config_dnn_search_distance_factory(
  char const * name, void ** obj,
  struct yac_param ** param, int * is_default) {
 
  YAC_ASSERT(obj, "missing object");
  YAC_ASSERT(param, "param is NULL");
  YAC_ASSERT(is_default, "is_default is NULL");
 
  *param = NULL;
  *is_default = 0;
 
  struct yac_interp_method_dnn_config_search_distance ** search_distance_ptr =
    (struct yac_interp_method_dnn_config_search_distance **)(obj);
 
  YAC_ASSERT(
    *search_distance_ptr == NULL, "search_distance pointer is not NULL");
 
  DEF_NAME_TYPE_PAIRS(
    search_distance_type_table,
    DEF_NAME_TYPE_PAIR(fixed, YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED),
    DEF_NAME_TYPE_PAIR(cell_area, YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA))
 
  int type =
    (name == NULL)?
      YAC_INTERP_DNN_SEARCH_DISTANCE_TYPE_DEFAULT :
      yac_name_type_pair_get_type(
        search_distance_type_table, search_distance_type_table_size, name);
 
  struct yac_interp_method_dnn_config_search_distance * search_distance = NULL;
 
  switch (type) {
    case YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED:
 
      search_distance = xmalloc(1 * sizeof(*search_distance));
 
      // set type
      search_distance->type = YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED;
 
      // set default
      search_distance->search_distance.fixed =
        YAC_INTERP_DNN_SEARCH_DISTANCE_FIXED_DEFAULT;
 
      break;
    case YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA:
 
      search_distance = xmalloc(1 * sizeof(*search_distance));
 
      // set type
      search_distance->type = YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA;
 
      // set default
      search_distance->search_distance.scale =
        YAC_INTERP_DNN_SEARCH_DISTANCE_CELL_AREA_DEFAULT;
 
      break;
    default:
      YAC_PARAM_ASSERT(0, "%s is not a invalid search distance type", name);
      break;
  }
 
  *is_default = type == YAC_INTERP_DNN_SEARCH_DISTANCE_TYPE_DEFAULT;
  *search_distance_ptr = search_distance;
  *param =
    yac_interp_method_dnn_config_search_distance_build_param(search_distance);
 
  return 0;
}
 
static struct yac_param *config_dnn_get_param(
  struct yac_interp_method_config const *config) {
  struct yac_interp_method_config_dnn *config_dnn =
    (struct yac_interp_method_config_dnn *)config;
 
  enum {
    WEIGHTED_HAS_DEFAULT = 1,
    WEIGHTED_IS_DEFINED = 1,
    N_MIN_HAS_DEFAULT = 1,
    N_MIN_IS_DEFINED = 1,
    GAUSS_SCALE_HAS_DEFAULT = 1,
    GAUSS_SCALE_IS_DEFINED = 1,
    RBF_SCALE_HAS_DEFAULT = 1,
    RBF_SCALE_IS_DEFINED = 1,
    SCALE_ALLOW_NAN = 0,
    SCALE_ALLOW_INF = 0,
  };
 
  DEF_NAME_TYPE_PAIRS(
    dnn_weighted_enum_table,
    DEF_NAME_TYPE_PAIR(distance_weighted, YAC_INTERP_DNN_WEIGHT_DIST),
    DEF_NAME_TYPE_PAIR(gauss_weighted, YAC_INTERP_DNN_WEIGHT_GAUSS),
    DEF_NAME_TYPE_PAIR(arithmetic_average, YAC_INTERP_DNN_WEIGHT_AVG),
    DEF_NAME_TYPE_PAIR(rbf_weighted, YAC_INTERP_DNN_WEIGHT_RBF))
 
  struct yac_param *weighted_param =
    yac_param_enum_new(
      "weighted",
      (int *)&config_dnn->config.type,
      YAC_INTERP_DNN_WEIGHT_DEFAULT,
      dnn_weighted_enum_table, dnn_weighted_enum_table_size,
      WEIGHTED_HAS_DEFAULT, WEIGHTED_IS_DEFINED);
 
  int const n_min_min = 1;
  int const n_min_max = INT_MAX;
 
  struct yac_param *n_min_param =
    yac_param_int_new(
      "n_min",
      &config_dnn->config.n_min,
      YAC_INTERP_DNN_N_MIN_DEFAULT,
      n_min_min, n_min_max,
      N_MIN_HAS_DEFAULT, N_MIN_IS_DEFINED);
 
  double const gauss_scale_min = -DBL_MAX;
  double const gauss_scale_max = DBL_MAX;
 
  struct yac_param *gauss_scale_param =
    yac_param_dble_new(
      "gauss_scale",
      &config_dnn->config.gauss_scale,
      YAC_INTERP_DNN_GAUSS_SCALE_DEFAULT,
      gauss_scale_min, gauss_scale_max,
      SCALE_ALLOW_NAN, SCALE_ALLOW_INF,
      GAUSS_SCALE_HAS_DEFAULT, GAUSS_SCALE_IS_DEFINED);
 
  double const rbf_scale_min = -DBL_MAX;
  double const rbf_scale_max = DBL_MAX;
 
  struct yac_param *rbf_scale_param =
    yac_param_dble_new(
      "rbf_scale",
      &config_dnn->config.rbf_scale,
      YAC_INTERP_DNN_RBF_SCALE_DEFAULT,
      rbf_scale_min, rbf_scale_max,
      SCALE_ALLOW_NAN, SCALE_ALLOW_INF,
      RBF_SCALE_HAS_DEFAULT, RBF_SCALE_IS_DEFINED);
 
  struct yac_param * search_distance_subparam =
    yac_interp_method_dnn_config_search_distance_build_param(
      config_dnn->config.search_distance);
 
  struct yac_param *search_distance_param =
    yac_param_oneof_new(
      "search_distance",
      config_dnn_search_distance_factory,
      (void **)&config_dnn->config.search_distance,
      search_distance_subparam,
      (config_dnn->config.search_distance == NULL) ||
      (config_dnn->config.search_distance->type ==
        YAC_INTERP_DNN_SEARCH_DISTANCE_TYPE_DEFAULT));
 
  struct yac_param *root_param_array[] = {
    weighted_param,
    n_min_param,
    gauss_scale_param,
    rbf_scale_param,
    search_distance_param,
  };
  return yac_param_struct_new(
    "dnn", root_param_array,
    sizeof(root_param_array) / sizeof(root_param_array[0]));
}
 
static struct yac_interp_method_config_vtable yac_interp_method_config_vtable_dnn = {
  .delete = config_dnn_delete,
  .copy = config_dnn_copy,
  .compare = config_dnn_compare,
  .get_type = config_dnn_get_type,
  .generate = config_dnn_generate,
  .get_param = config_dnn_get_param
};
 
struct yac_interp_method_config *yac_interp_method_config_default_dnn_new(void) {
  struct yac_interp_method_config_dnn *config_dnn = xmalloc(sizeof(*config_dnn));
  config_dnn->base.vtable = &yac_interp_method_config_vtable_dnn;
  config_dnn->base.root_param_cache = NULL;
  config_dnn->config = (struct yac_interp_method_dnn_config){
    .type = YAC_INTERP_DNN_WEIGHT_DEFAULT,
    .search_distance = NULL,
    .n_min = YAC_INTERP_DNN_N_MIN_DEFAULT,
    .gauss_scale = YAC_INTERP_DNN_GAUSS_SCALE_DEFAULT,
    .rbf_scale = YAC_INTERP_DNN_RBF_SCALE_DEFAULT,
  };
  return (struct yac_interp_method_config *)config_dnn;
}