param_distance.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include "param_distance.h"
#include "param_dble.h"
#include "param_internal.h"
#include "geometry.h"
#include "yac_assert.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>
 
struct yac_param_distance {
  const struct yac_param_vtable *vtable;
  struct yac_param *dble_param;
};
 
static enum yac_param_type
  yac_param_distance_get_type(
  const struct yac_param *param) {
  UNUSED(param);
  return YAC_PARAM_TYPE_SCALAR;
}
 
static int yac_param_distance_is_default(
  const struct yac_param *param) {
  const struct yac_param_distance *self =
    (const struct yac_param_distance *)param;
  return yac_param_is_default(self->dble_param);
}
 
static const char *yac_param_distance_get_name(
  const struct yac_param *param) {
  const struct yac_param_distance *self =
    (const struct yac_param_distance *)param;
  return yac_param_get_name(self->dble_param);
}
 
static void yac_param_distance_delete(
  struct yac_param *param) {
  struct yac_param_distance *self =
    (struct yac_param_distance *)param;
  yac_param_delete(self->dble_param);
  free(self);
}
 
static int yac_param_distance_set_scalar_dble(
  struct yac_param *param, double value) {
  struct yac_param_distance *self =
    (struct yac_param_distance *)param;
  return yac_param_set_scalar_dble(
    self->dble_param, value);
}
 
static int yac_param_distance_set_scalar(
  struct yac_param *param, const char *value_str) {
  double value;
  enum yac_param_angle_unit unit = YAC_PARAM_ANGLE_UNIT_DEG;
  if (yac_param_parse_dble_with_unit(
        value_str, yac_param_get_name(param), &value,
        &unit)) return 1;
  if (unit == YAC_PARAM_ANGLE_UNIT_DEG) {
    value = yac_deg_to_rad(value, yac_param_get_name(param));
  }
  return
    yac_param_distance_set_scalar_dble(
      param, value);
}
 
static int yac_param_distance_get_scalar_dble(
  const struct yac_param *param, double *value) {
  const struct yac_param_distance *self =
    (const struct yac_param_distance *)param;
  int rc = yac_param_get_scalar_dble(
    self->dble_param, value);
  if (rc) return rc;
  return 0;
}
 
static int yac_param_distance_get_scalar(
  const struct yac_param *param, char *buf, size_t buflen) {
  double value;
  int rc =
    yac_param_distance_get_scalar_dble(
      param, &value);
  if (rc) return rc;
  value = yac_rad_to_deg(value, yac_param_get_name(param));
  return yac_param_format_scalar_dble(
    buf, buflen, value, "distance value",
    yac_param_get_name(param));
}
 
static int yac_param_distance_set_scalar_int(
  struct yac_param *param, int value) {
  return yac_param_distance_set_scalar_dble(param, (double)value);
}
 
static int yac_param_distance_get_scalar_int(
  const struct yac_param *param, int *value) {
  double dval;
  int ret = yac_param_distance_get_scalar_dble(param, &dval);
  if (!ret)  {
    YAC_PARAM_ASSERT(
      (fmod(dval, 1.0) == 0.0) &&
      (dval >= (double)INT_MIN) && (dval <= (double)INT_MAX),
      "distance value %g cannot be converted to integer without loss "
      "for parameter '%s'",
      dval, yac_param_get_name(param));
    *value = (int)dval;
  }
  return ret;
}
 
static const struct yac_param_vtable
  yac_param_distance_vtable = {
  .get_type = yac_param_distance_get_type,
  .is_default = yac_param_distance_is_default,
  .get_name = yac_param_distance_get_name,
  .delete = yac_param_distance_delete,
  .get_sub_count = NULL,
  .get_sub_by_name = NULL,
  .get_sub_by_index = NULL,
  .append = NULL,
  .set_scalar = yac_param_distance_set_scalar,
  .get_scalar = yac_param_distance_get_scalar,
  .set_scalar_int = yac_param_distance_set_scalar_int,
  .set_scalar_dble = yac_param_distance_set_scalar_dble,
  .get_scalar_int = yac_param_distance_get_scalar_int,
  .get_scalar_dble = yac_param_distance_get_scalar_dble
};
 
struct yac_param *
yac_param_distance_new(
  const char *name, double *value_ptr, double default_value,
  double value_min, double value_max, int has_default, int is_defined) {
 
  YAC_PARAM_CHECK_BASIC();
  YAC_ASSERT_F(
    !isnan(value_min) && isfinite(value_min),
    "value_min (%g) is not finite for parameter '%s'",
    value_min, name);
  YAC_ASSERT_F(
    !isnan(value_max) && isfinite(value_max),
    "value_max (%g) is not finite for parameter '%s'",
    value_max, name);
  YAC_ASSERT_F(
    value_min >= 0.0, "value_min (%g) < 0 for parameter '%s'", value_min, name);
  YAC_ASSERT_F(
    value_max <= M_PI, "value_max (%g) > M_PI for parameter '%s'",
    value_max, name);
  YAC_ASSERT_F(
    !has_default || (!isnan(default_value) && !isinf(default_value)),
    "default_value (%g) is not finite for parameter '%s' (has_default is true)",
    default_value, name);
  YAC_ASSERT_F(
    value_min <= value_max,
    "value_min (%g) is greater than value_max (%g) for parameter '%s'",
    value_min, value_max, name);
  struct yac_param_distance *self =
    malloc(sizeof(*self));
  self->vtable = &yac_param_distance_vtable;
  self->dble_param = yac_param_dble_new(
    name, value_ptr, default_value, value_min, value_max, 0, 0, has_default,
    is_defined);
  return (struct yac_param *)self;
}