rnsf

commit 14d833ff0970e3255de48bb50a57ecfbc6c27e46
parent b8b6a3cb74cc201ff11c80cbef0ac934a7d5ea80
Author: Vincent Forest <vincent.forest@meso-star.com>
Date:   Mon, 20 Jun 2022 14:58:10 +0200

Implemente rnsf_create and rnsf_ref_<get|put>

Diffstat:
A
cmake/CMakeLists.txt
 | 
125
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
src/rnsf.c
 | 
116
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
src/rnsf_c.h
 | 
45
+++++++++++++++++++++++++++++++++++++++++++++
A
src/rnsf_log.c
 | 
134
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
src/rnsf_log.h
 | 
78
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
src/rnsf_phase_fn.h
 | 
180
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

6 files changed, 678 insertions(+), 0 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -0,0 +1,125 @@
+# Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+# Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+# Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+# Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay,
+#                    Sorbonne Université, CNRS
+# Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+#                    Sorbonne Université, Université Paris Cité
+# Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+#                    Ecole Polytechnique, Institut Polytechnique de Paris,
+#                    CNRS
+# Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+#
+# This program 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.
+#
+# This program 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 for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+cmake_minimum_required(VERSION 3.1)
+project(rnsf C)
+enable_testing()
+
+set(RNSF_SOURCE_DIR ${PROJECT_SOURCE_DIR}/../src)
+option(NO_TEST "Do not build tests" OFF)
+
+################################################################################
+# Check dependencies
+################################################################################
+find_package(RCMake 0.4 REQUIRED)
+find_package(RSys 0.9 REQUIRED)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${RCMAKE_SOURCE_DIR})
+include(rcmake)
+include(rcmake_runtime)
+
+include_directories(${RSys_INCLUDE_DIR})
+
+################################################################################
+# Configure and define targets
+################################################################################
+set(VERSION_MAJOR 0)
+set(VERSION_MINOR 0)
+set(VERSION_PATCH 0)
+set(VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})
+
+set(RNSF_FILES_SRC
+  rnsf.c
+  rnsf_log.c)
+set(RNSF_FILES_INC 
+  rnsf_c.h
+  rnsf_log.h
+  rnsf_phase_fn.h)
+set(RNSF_FILES_INC_API rnsf.h)
+set(RNSF_FILES_DOC COPYING README.md)
+
+# Prepend each file in the `RNSF_FILES_<SRC|INC>' list by `RNSF_SOURCE_DIR'
+rcmake_prepend_path(RNSF_FILES_SRC ${RNSF_SOURCE_DIR})
+rcmake_prepend_path(RNSF_FILES_INC ${RNSF_SOURCE_DIR})
+rcmake_prepend_path(RNSF_FILES_INC_API ${RNSF_SOURCE_DIR})
+rcmake_prepend_path(RNSF_FILES_DOC ${PROJECT_SOURCE_DIR}/../)
+
+add_library(rnsf SHARED ${RNSF_FILES_SRC} ${RNSF_FILES_INC} ${RNSF_FILES_INC_API})
+target_link_libraries(rnsf RSys)
+
+set_target_properties(rnsf PROPERTIES
+  DEFINE_SYMBOL RNSF_SHARED_BUILD
+  VERSION ${VERSION}
+  SOVERSION ${VERSION_MAJOR})
+
+rcmake_setup_devel(rnsf RNSF ${VERSION} rad-net/rnsf_version.h)
+
+################################################################################
+# Add tests
+################################################################################
+if(NOT NO_TEST)
+  function(build_test _name)
+    add_executable(${_name}
+      ${RNSF_SOURCE_DIR}/${_name}.c)
+    target_link_libraries(${_name} rnsf RSys)
+  endfunction()
+
+  function(new_test _name)
+    build_test(${_name})
+    add_test(${_name} ${_name})
+  endfunction()
+endif()
+
+################################################################################
+# Man pages
+###############################################################################
+find_program(SCDOC NAMES scdoc)
+if(NOT SCDOC)
+  message(WARNING
+    "The `scdoc' program is missing. "
+    "The rnsf man page cannot be generated.")
+else()
+  set(_src ${PROJECT_SOURCE_DIR}/../doc/rnsf.5.scd)
+  add_custom_command(
+    OUTPUT rnsf.5
+    COMMAND ${SCDOC} < ${_src} > rnsf.5
+    DEPENDS ${_src}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    COMMENT "Buid ROFF man page rnsf.5"
+    VERBATIM)
+  add_custom_target(man-roff ALL DEPENDS rnsf.5)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/rnsf.5 DESTINATION share/man/man5)
+endif()
+
+################################################################################
+# Define output & install directories
+################################################################################
+install(TARGETS rnsf
+  ARCHIVE DESTINATION bin
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin)
+install(FILES ${RNSF_FILES_INC_API} DESTINATION include/rad-net)
+install(FILES ${RNSF_FILES_DOC} DESTINATION share/doc/rnsf)
+
diff --git a/src/rnsf.c b/src/rnsf.c
@@ -0,0 +1,116 @@
+/* Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+ * Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+ * Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+ * Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay, 
+ *                    Sorbonne Université, CNRS
+ * Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+ *                    Sorbonne Université, Université Paris Cité
+ * Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+ *                    Ecole Polytechnique, Institut Polytechnique de Paris,
+ *                    CNRS
+ * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program 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.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "rnsf.h"
+#include "rnsf_c.h"
+#include "rnsf_log.h"
+
+/*******************************************************************************
+ * Helper functions
+ ******************************************************************************/
+static INLINE res_T
+check_rnsf_create_args(const struct rnsf_create_args* args)
+{
+  /* Nothing to check. Only return RES_BAD_ARG if args is NULL */
+  return args ? RES_OK : RES_BAD_ARG;
+}
+
+static void
+release_rnsf(ref_T* ref)
+{
+  struct rnsf* rnsf = NULL;
+  ASSERT(ref);
+  rnsf = CONTAINER_OF(ref, struct rnsf, ref);
+  if(rnsf->logger == &rnsf->logger__) logger_release(&rnsf->logger__);
+  darray_phase_fn_release(&rnsf->phases);
+  MEM_RM(rnsf->allocator, rnsf);
+}
+
+/*******************************************************************************
+ * Exported functions
+ ******************************************************************************/
+res_T
+rnsf_create
+  (const struct rnsf_create_args* args,
+   struct rnsf** out_rnsf)
+{
+  struct rnsf* rnsf = NULL;
+  struct mem_allocator* allocator = NULL;
+  res_T res = RES_OK;
+
+  if(!out_rnsf) { res = RES_BAD_ARG; goto error; }
+  res = check_rnsf_create_args(args);
+  if(res != RES_OK) goto error;
+
+  allocator = args->allocator ? args->allocator : &mem_default_allocator;
+  rnsf = MEM_CALLOC(allocator, 1, sizeof(*rnsf));
+  if(!rnsf) {
+    if(args->verbose) {
+      #define ERR_STR "Could not allocate the device of the "\
+        "Rad-Net Scattering Function library.\n"
+      if(args->logger) {
+        logger_print(args->logger, LOG_ERROR, ERR_STR);
+      } else {
+        fprintf(stderr, MSG_ERROR_PREFIX ERR_STR);
+      }
+      #undef ERR_STR
+    }
+    res = RES_MEM_ERR;
+    goto error;
+  }
+
+  ref_init(&rnsf->ref);
+  rnsf->allocator = allocator;
+  rnsf->verbose = args->verbose;
+  darray_phase_fn_init(allocator, &rnsf->phases);
+  if(args->logger) {
+    rnsf->logger = args->logger;
+  } else {
+    setup_log_default(rnsf);
+  }
+
+exit:
+  if(out_rnsf) *out_rnsf = rnsf ;
+  return res;
+error:
+  if(rnsf) { RNSF(ref_put(rnsf)); rnsf = NULL; }
+  goto exit;
+}
+
+res_T
+rnsf_ref_get(struct rnsf* rnsf)
+{
+  if(!rnsf) return RES_BAD_ARG;
+  ref_get(&rnsf->ref);
+  return RES_OK;
+}
+
+res_T
+rnsf_ref_put(struct rnsf* rnsf)
+{
+  if(!rnsf) return RES_BAD_ARG;
+  ref_put(&rnsf->ref, release_rnsf);
+  return RES_OK;
+}
diff --git a/src/rnsf_c.h b/src/rnsf_c.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+ * Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+ * Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+ * Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay, 
+ *                    Sorbonne Université, CNRS
+ * Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+ *                    Sorbonne Université, Université Paris Cité
+ * Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+ *                    Ecole Polytechnique, Institut Polytechnique de Paris,
+ *                    CNRS
+ * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program 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.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef RNSF_C_H
+#define RNSF_C_H
+
+#include "rnsf_phase_fn.h"
+
+#include <rsys/mem_allocator.h>
+#include <rsys/logger.h>
+#include <rsys/ref_count.h>
+
+struct rnsf {
+  struct darray_phase_fn phases;
+
+  int verbose; /* Verbosity level */
+  struct logger* logger;
+  struct logger logger__;
+  struct mem_allocator* allocator;
+  ref_T ref;
+};
+
+#endif /* RNSF_C_H */
diff --git a/src/rnsf_log.c b/src/rnsf_log.c
@@ -0,0 +1,134 @@
+/* Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+ * Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+ * Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+ * Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay, 
+ *                    Sorbonne Université, CNRS
+ * Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+ *                    Sorbonne Université, Université Paris Cité
+ * Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+ *                    Ecole Polytechnique, Institut Polytechnique de Paris,
+ *                    CNRS
+ * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program 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.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include "rnsf_c.h"
+#include "rnsf_log.h"
+
+#include <rsys/cstr.h>
+#include <rsys/logger.h>
+
+#include <stdarg.h>
+
+/*******************************************************************************
+ * Helper functions
+ ******************************************************************************/
+static INLINE void
+log_msg
+  (const struct rnsf* rnsf,
+   const enum log_type stream,
+   const char* msg,
+   va_list vargs)
+{
+  ASSERT(rnsf && msg);
+  if(rnsf->verbose) {
+    res_T res; (void)res;
+    res = logger_vprint(rnsf->logger, stream, msg, vargs);
+    ASSERT(res == RES_OK);
+  }
+}
+
+static void
+print_info(const char* msg, void* ctx)
+{
+  (void)ctx;
+  fprintf(stderr, MSG_INFO_PREFIX"%s", msg);
+}
+
+static void
+print_err(const char* msg, void* ctx)
+{
+  (void)ctx;
+  fprintf(stderr, MSG_ERROR_PREFIX"%s", msg);
+}
+
+static void
+print_warn(const char* msg, void* ctx)
+{
+  (void)ctx;
+  fprintf(stderr, MSG_WARNING_PREFIX"%s", msg);
+}
+
+/*******************************************************************************
+ * Local functions
+ ******************************************************************************/
+res_T
+setup_log_default(struct rnsf* rnsf)
+{
+  res_T res = RES_OK;
+  ASSERT(rnsf);
+
+  res = logger_init(rnsf->allocator, &rnsf->logger__);
+  if(res != RES_OK) {
+    if(rnsf->verbose) {
+      fprintf(stderr,
+        MSG_ERROR_PREFIX
+        "Could not setup the default logger -- %s.\n",
+        res_to_cstr(res));
+    }
+    goto error;
+  }
+  logger_set_stream(&rnsf->logger__, LOG_OUTPUT, print_info, NULL);
+  logger_set_stream(&rnsf->logger__, LOG_ERROR, print_err, NULL);
+  logger_set_stream(&rnsf->logger__, LOG_WARNING, print_warn, NULL);
+  rnsf->logger = &rnsf->logger__;
+
+exit:
+  return res;
+error:
+  goto exit;
+}
+
+void
+log_info(const struct rnsf* rnsf, const char* msg, ...)
+{
+  va_list vargs_list;
+  ASSERT(rnsf && msg);
+
+  va_start(vargs_list, msg);
+  log_msg(rnsf, LOG_OUTPUT, msg, vargs_list);
+  va_end(vargs_list);
+}
+
+void
+log_err(const struct rnsf* rnsf, const char* msg, ...)
+{
+  va_list vargs_list;
+  ASSERT(rnsf && msg);
+
+  va_start(vargs_list, msg);
+  log_msg(rnsf, LOG_ERROR, msg, vargs_list);
+  va_end(vargs_list);
+}
+
+void
+log_warn(const struct rnsf* rnsf, const char* msg, ...)
+{
+  va_list vargs_list;
+  ASSERT(rnsf && msg);
+
+  va_start(vargs_list, msg);
+  log_msg(rnsf, LOG_WARNING, msg, vargs_list);
+  va_end(vargs_list);
+}
diff --git a/src/rnsf_log.h b/src/rnsf_log.h
@@ -0,0 +1,78 @@
+/* Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+ * Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+ * Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+ * Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay, 
+ *                    Sorbonne Université, CNRS
+ * Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+ *                    Sorbonne Université, Université Paris Cité
+ * Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+ *                    Ecole Polytechnique, Institut Polytechnique de Paris,
+ *                    CNRS
+ * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program is free software: you can redismshbute 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.
+ *
+ * This program is dismshbuted 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef RNSF_LOG_H
+#define RNSF_LOG_H
+
+#include <rsys/rsys.h>
+
+#define MSG_INFO_PREFIX "Rad-Net Scatt Func:\x1b[1m\x1b[32minfo\x1b[0m: "
+#define MSG_ERROR_PREFIX "Rad-Net Scatt Func:\x1b[1m\x1b[31merror\x1b[0m: "
+#define MSG_WARNING_PREFIX "Rad-Net Scat Func:\x1b[1m\x1b[33mwarning\x1b[0m: "
+
+struct rnsf;
+struct logger;
+
+extern LOCAL_SYM res_T
+setup_log_default
+  (struct rnsf* rnsf);
+
+/* Conditionally log a message on the LOG_OUTPUT stream of the rnsf logger,
+ * with respect to its verbose flag */
+extern LOCAL_SYM void
+log_info
+  (const struct rnsf* rnsf,
+   const char* msg,
+   ...)
+#ifdef COMPILER_GCC
+  __attribute((format(printf, 2, 3)))
+#endif
+;
+
+/* Conditionally log a message on the LOG_ERROR stream of the rnsf logger,
+ * with respect to its verbose flag */
+extern LOCAL_SYM void
+log_err
+  (const struct rnsf* rnsf,
+   const char* msg,
+   ...)
+#ifdef COMPILER_GCC
+  __attribute((format(printf, 2, 3)))
+#endif
+;
+
+/* Conditionally log a message on the LOG_WARNING stream of the rnsf logger,
+ * with respect to its verbose flag */
+extern LOCAL_SYM void
+log_warn
+  (const struct rnsf* rnsf,
+   const char* msg,
+   ...)
+#ifdef COMPILER_GCC
+    __attribute((format(printf, 2, 3)))
+#endif
+;
+
+#endif /* RNSF_LOG_H */
diff --git a/src/rnsf_phase_fn.h b/src/rnsf_phase_fn.h
@@ -0,0 +1,180 @@
+/* Copyright (C) 2022 GSMA - Université de Reims Champgne-Ardenne, CNRS
+ * Copyright (C) 2022 IPGP, Université Paris Cité, CNRS
+ * Copyright (C) 2022 LAPLACE - Université de Toulouse, CNRS, INPT, UPS
+ * Copyright (C) 2022 LATMOS/IPSL - UVSQ, Université Paris-Saclay, 
+ *                    Sorbonne Université, CNRS
+ * Copyright (C) 2022 LESIA - Observatoire de Paris, Université PSL,
+ *                    Sorbonne Université, Université Paris Cité
+ * Copyright (C) 2022 LMD/IPSL - Sorbonne Université, Université PSL,
+ *                    Ecole Polytechnique, Institut Polytechnique de Paris,
+ *                    CNRS
+ * Copyright (C) 2022 |Meso|Star> (contact@meso-star.com)
+ *
+ * This program 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.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#ifndef RNSF_PHASE_FN_H
+#define RNSF_PHASE_FN_H
+
+#include "rnsf.h"
+#include <rsys/dynamic_array.h>
+
+struct phase_fn_hg {
+  double g; /* Asymmetric parameter in [-1, 1] */
+};
+
+struct discrete_item {
+  double theta; /* In radian */
+  double value;
+};
+
+/* Generate the dynamic array of discrete items */
+#define DARRAY_NAME discrete_item
+#define DARRAY_DATA struct discrete_item
+#include <rsys/dynamic_array.h>
+
+struct phase_fn_discrete {
+  struct darray_discrete_item items;
+};
+
+static INLINE res_T
+phase_fn_discrete_init
+  (struct mem_allocator* allocator,
+   struct phase_fn_discrete* phase)
+{
+  ASSERT(phase);
+  darray_discrete_item_init(allocator, &phase->items);
+  return RES_OK;
+}
+
+static INLINE void
+phase_fn_discrete_release(struct phase_fn_discrete* phase)
+{
+  ASSERT(phase);
+  darray_discrete_item_release(&phase->items);
+}
+
+static INLINE res_T
+phase_fn_discrete_copy
+  (struct phase_fn_discrete* dst,
+   const struct phase_fn_discrete* src)
+{
+  ASSERT(src && dst);
+  return darray_discrete_item_copy(&dst->items, &src->items);
+}
+
+static INLINE res_T
+phase_fn_discrete_copy_and_release
+  (struct phase_fn_discrete* dst,
+   struct phase_fn_discrete* src)
+{
+  ASSERT(src && dst);
+  return darray_discrete_item_copy_and_release(&dst->items, &src->items);
+}
+
+struct rnsf_phase_fn {
+  double wlen[2]; /* In nanometers */
+  enum rnsf_phase_fn_type type;
+  union {
+    struct phase_fn_hg hg;
+    struct phase_fn_discrete discrete;
+  } param;
+};
+
+static INLINE res_T
+phase_fn_init
+  (struct mem_allocator* allocator,
+   struct rnsf_phase_fn* phase)
+{
+  ASSERT(phase);
+  (void)allocator;
+  phase->wlen[0] = 0;
+  phase->wlen[1] = 0;
+  phase->type = RNSF_PHASE_FN_NONE__;
+  return RES_OK;
+}
+
+static INLINE void
+phase_fn_release(struct rnsf_phase_fn* phase)
+{
+  ASSERT(phase);
+  switch(phase->type) {
+    case RNSF_PHASE_FN_HG:
+    case RNSF_PHASE_FN_NONE__:
+      /* Do nothing */
+      break;
+    case RNSF_PHASE_FN_DISCRETE:
+      phase_fn_discrete_release(&phase->param.discrete);
+      break;
+    default: FATAL("Unreachable code.\n"); break;
+  }
+}
+
+static INLINE res_T
+phase_fn_copy
+  (struct rnsf_phase_fn* dst,
+   const struct rnsf_phase_fn* src)
+{
+  res_T res = RES_OK;
+  dst->wlen[0] = src->wlen[0];
+  dst->wlen[1] = src->wlen[1];
+  dst->type = src->type;
+  switch(src->type) {
+    case RNSF_PHASE_FN_HG:
+      dst->param.hg.g = src->param.hg.g;
+      break;
+    case RNSF_PHASE_FN_DISCRETE:
+      res = phase_fn_discrete_copy
+        (&dst->param.discrete,
+         &src->param.discrete);
+      break;
+    case RNSF_PHASE_FN_NONE__: /* Do nothing */ break;
+    default: FATAL("Unreachable code.\n"); break;
+  }
+  return res;
+}
+
+static INLINE res_T
+phase_fn_copy_and_release
+  (struct rnsf_phase_fn* dst,
+   struct rnsf_phase_fn* src)
+{
+  res_T res = RES_OK;
+  dst->wlen[0] = src->wlen[0];
+  dst->wlen[1] = src->wlen[1];
+  dst->type = src->type;
+  switch(src->type) {
+    case RNSF_PHASE_FN_HG:
+      dst->param.hg.g = src->param.hg.g;
+      break;
+    case RNSF_PHASE_FN_DISCRETE:
+      res = phase_fn_discrete_copy_and_release
+        (&dst->param.discrete,
+         &src->param.discrete);
+      break;
+    case RNSF_PHASE_FN_NONE__: /* Do nothing */ break;
+    default: FATAL("Unreachable code.\n"); break;
+  }
+  return res;
+}
+
+/* Generate the dynamic array of phase functions */
+#define DARRAY_NAME phase_fn
+#define DARRAY_DATA struct rnsf_phase_fn
+#define DARRAY_FUNCTOR_INIT phase_fn_init
+#define DARRAY_FUNCTOR_RELEASE phase_fn_release
+#define DARRAY_FUNCTOR_COPY phase_fn_copy
+#define DARRAY_FUNCTOR_COPY_AND_RELEASE phase_fn_copy_and_release
+#include <rsys/dynamic_array.h>
+
+#endif /* RNSF_PHASE_FN_H */