param_angle.c

Go to the documentation of this file.

// Copyright (c) 2026 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <limits.h>
 
#include "param_angle.h"
#include "param_dble.h"
#include "param_internal.h"
#include "utils_common.h"
#include "ppm/core.h"
#include "yac_assert.h"
 
struct yac_param_angle {
  const struct yac_param_vtable *vtable;
  struct yac_param *dble_param;
};
 
static enum yac_param_type
  yac_param_angle_get_type(
  const struct yac_param *param) {
  UNUSED(param);
  return YAC_PARAM_TYPE_SCALAR;
}
 
static int yac_param_angle_is_default(
  const struct yac_param *param) {
  const struct yac_param_angle *self =
    (const struct yac_param_angle *)param;
  return yac_param_is_default(self->dble_param);
}
 
static const char *yac_param_angle_get_name(
  const struct yac_param *param) {
  const struct yac_param_angle *self =
    (const struct yac_param_angle *)param;
  return yac_param_get_name(self->dble_param);
}
 
static void yac_param_angle_delete(
  struct yac_param *param) {
  struct yac_param_angle *self =
    (struct yac_param_angle *)param;
  yac_param_delete(self->dble_param);
  free(self);
}
 
static int yac_param_angle_set_scalar_dble(
  struct yac_param *param, double value) {
  struct yac_param_angle *self =
    (struct yac_param_angle *)param;
  char const * param_name = yac_param_get_name(param);
 
  value = yac_wrap_rad(value, param_name);
 
  return yac_param_set_scalar_dble(
    self->dble_param, value);
}
 
static int yac_param_angle_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_angle_set_scalar_dble(param, value);
}
 
static int yac_param_angle_get_scalar_dble(
  const struct yac_param *param, double *value) {
  const struct yac_param_angle *self =
    (const struct yac_param_angle *)param;
  return yac_param_get_scalar_dble(
    self->dble_param, value);
}
 
static int yac_param_angle_get_scalar(
  const struct yac_param *param, char *buf, size_t buflen) {
  double value;
  int ret = yac_param_angle_get_scalar_dble(param, &value);
  if (!ret) {
    value = yac_rad_to_deg(value, yac_param_get_name(param));
    ret =
      yac_param_format_scalar_dble(
        buf, buflen, value, "angle value",
        yac_param_get_name(param));
  }
  return ret;
}
 
static int yac_param_angle_get_scalar_kind(
  const struct yac_param *param,
  enum yac_param_scalar_kind *scalar_kind) {
  const struct yac_param_angle *self =
    (const struct yac_param_angle *)param;
  return yac_param_get_scalar_kind(self->dble_param, scalar_kind);
}
 
static int yac_param_angle_set_scalar_int(
  struct yac_param *param, int value) {
  return yac_param_angle_set_scalar_dble(param, (double)value);
}
 
static int yac_param_angle_get_scalar_int(
  const struct yac_param *param, int *value) {
  double dval;
  int ret = yac_param_angle_get_scalar_dble(param, &dval);
  if (!ret) {
    YAC_PARAM_ASSERT(
      (fmod(dval, 1.0) == 0.0) &&
      (dval >= (double)INT_MIN) && (dval <= (double)INT_MAX),
      "angle 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_angle_vtable = {
  .get_type = yac_param_angle_get_type,
  .is_default = yac_param_angle_is_default,
  .get_name = yac_param_angle_get_name,
  .delete = yac_param_angle_delete,
  .get_sub_count = NULL,
  .get_sub_by_name = NULL,
  .get_sub_by_index = NULL,
  .append = NULL,
  .set_scalar = yac_param_angle_set_scalar,
  .get_scalar = yac_param_angle_get_scalar,
  .get_scalar_kind = yac_param_angle_get_scalar_kind,
  .set_scalar_int = yac_param_angle_set_scalar_int,
  .set_scalar_dble = yac_param_angle_set_scalar_dble,
  .get_scalar_int = yac_param_angle_get_scalar_int,
  .get_scalar_dble = yac_param_angle_get_scalar_dble
};
 
struct yac_param *yac_param_angle_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(
    is_defined || (!isnan(*value_ptr) && !isinf(*value_ptr)),
    "initial value (%g) is not finite for parameter '%s'",
    *value_ptr, name);
  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(
    !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);
 
  if (has_default) default_value = yac_wrap_rad(default_value, name);
 
  if (is_defined) *value_ptr = yac_wrap_rad(*value_ptr, name);
 
  struct yac_param_angle *self = xmalloc(sizeof(*self));
  self->vtable = &yac_param_angle_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;
}