gm_to_dirac_even_binf.h

#ifndef GM_TO_DIRAC_EVEN_BINF_H
#define GM_TO_DIRAC_EVEN_BINF_H
 
#include "approximate_options.h"
#include "gm_to_dirac_even_binf_optimization_params.h"
#include "gsl_minimizer.h"
#include "gsl_vector_matrix_types.h"
 
template <typename T>
class gm_to_dirac_even_binf {
 public:
  using GSLVectorType = typename GSLTemplateTypeAlias<T>::VectorType;
  using GSLMatrixType = typename GSLTemplateTypeAlias<T>::MatrixType;
 
  // clang-format off
  bool approximate(size_t L,
                   size_t N,
                   T* x,
                   const T* wX = nullptr,
                   GslminimizerResult* result = nullptr,
                   const ApproximateOptions& options = ApproximateOptions{});
 
  void modified_van_mises_distance_sq(T* distance,
                                      size_t L,
                                      size_t N,
                                      T* x,
                                      const T* wX = nullptr);
 
  void modified_van_mises_distance_sq_derivative(T* gradient,
                                                 size_t L,
                                                 size_t N,
                                                 T* x,
                                                 const T* wX = nullptr);
 
  bool approximate(size_t L,
                   size_t N,
                   GSLVectorType* x,
                   const GSLVectorType* wX = nullptr,
                   GslminimizerResult* result = nullptr,
                   const ApproximateOptions& options = ApproximateOptions{});
 
  void modified_van_mises_distance_sq(T* distance,
                                      size_t L,
                                      size_t N,
                                      GSLVectorType* x,
                                      const GSLVectorType* wX = nullptr);
 
  void modified_van_mises_distance_sq_derivative(GSLVectorType* gradient,
                                                 size_t L,
                                                 size_t N,
                                                 GSLVectorType* x,
                                                 const GSLVectorType* wX = nullptr);
 
  bool approximate(size_t L,
                   size_t N,
                   GSLMatrixType* x,
                   const GSLVectorType* wX = nullptr,
                   GslminimizerResult* result = nullptr,
                   const ApproximateOptions& options = ApproximateOptions{});
 
  void modified_van_mises_distance_sq(T* distance,
                                      size_t L,
                                      size_t N,
                                      GSLMatrixType* x,
                                      const GSLVectorType* wX = nullptr);
 
  void modified_van_mises_distance_sq_derivative(GSLMatrixType* gradient,
                                                 size_t L,
                                                 size_t N,
                                                 GSLMatrixType* x,
                                                 const GSLVectorType* wX = nullptr);
  // clang-format on
 
 private:
  static void evaluate(const gsl_vector* t,
                       GMToDiracEvenBinfOptimizationParams* params, double* f,
                       gsl_vector* grad, bool chainRuleToT);
 
  // gsl_minimizer entry points; these always work in t
  static double modified_van_mises_distance_sq(const gsl_vector* t,
                                               void* params);
  static void modified_van_mises_distance_sq_derivative(const gsl_vector* t,
                                                        void* params,
                                                        gsl_vector* grad);
  static void combined_distance_metric(const gsl_vector* t, void* params,
                                       double* f, gsl_vector* grad);
 
  static inline void calculateAttraction(
      GMToDiracEvenBinfOptimizationParams* params, double* f, gsl_vector* grad);
 
  static inline void calculateRepulsion(
      GMToDiracEvenBinfOptimizationParams* params, double* f, gsl_vector* grad);
 
  static inline void projectGradient(
      const GMToDiracEvenBinfOptimizationParams* params, gsl_vector* grad);
 
  static inline void correctMean(gsl_vector* x, const gsl_vector* wX, size_t L,
                                 size_t N);
 
  static inline bool preconditionsHold(size_t L, size_t N);
};
 
#include "gm_to_dirac_even_binf.tpp"
 
template <>
bool gm_to_dirac_even_binf<float>::approximate(
    size_t L, size_t N, gsl_vector_float* x, const gsl_vector_float* wX,
    GslminimizerResult* result, const ApproximateOptions& options);
 
template <>
bool gm_to_dirac_even_binf<double>::approximate(
    size_t L, size_t N, gsl_vector* x, const gsl_vector* wX,
    GslminimizerResult* result, const ApproximateOptions& options);
 
template <>
void gm_to_dirac_even_binf<float>::modified_van_mises_distance_sq(
    float* distance, size_t L, size_t N, gsl_vector_float* x,
    const gsl_vector_float* wX);
 
template <>
void gm_to_dirac_even_binf<double>::modified_van_mises_distance_sq(
    double* distance, size_t L, size_t N, gsl_vector* x, const gsl_vector* wX);
 
template <>
void gm_to_dirac_even_binf<float>::modified_van_mises_distance_sq_derivative(
    gsl_vector_float* gradient, size_t L, size_t N, gsl_vector_float* x,
    const gsl_vector_float* wX);
 
template <>
void gm_to_dirac_even_binf<double>::modified_van_mises_distance_sq_derivative(
    gsl_vector* gradient, size_t L, size_t N, gsl_vector* x,
    const gsl_vector* wX);
 
extern template class gm_to_dirac_even_binf<double>;
extern template class gm_to_dirac_even_binf<float>;
 
#endif  // GM_TO_DIRAC_EVEN_BINF_H