GFunctions::eval() returns GNdarray instead of GVector (#3328)

The handling of GNdarray is more universal than the handling of GVector objects.

GFunctions::eval() returns GNdarray instead of GVector (#3328)
The handling of GNdarray is more universal than the handling of GVector objects.
Jürgen Knödlseder
1 parent dbe8a50a
Showing 6 changed files with 41 additions and 38 deletions
include/GFunctions.hpp
inst/cta/include/GCTABackgroundPerfTable.hpp
pyext/GFunctions.i
src/numerics/GFunctions.cpp
test/test_GNumerics.cpp
test/test_GNumerics.hpp
 /***************************************************************************
- *  GFunctions.hpp - Single parameter vector function abstract base class  *
+ *     GFunctions.hpp - Single parameter functions abstract base class     *
  * ----------------------------------------------------------------------- *
  *  copyright (C) 2020 by Juergen Knoedlseder                              *
  * ----------------------------------------------------------------------- *
@@ -20,7 +20,7 @@
  ***************************************************************************/
 /**
  * @file GFunctions.hpp
- * @brief Single parameter vector function abstract base class definition
+ * @brief Single parameter functions abstract base class definition
  * @author Juergen Knoedlseder
  */
  
@@ -30,23 +30,22 @@
 /* __ Includes ___________________________________________________________ */
  
 /* __ Forward declarations _______________________________________________ */
-class GVector;
+class GNdarray;
  
  
 /***********************************************************************//**
  * @class GFunctions
  *
- * @brief Single parameter vector function abstract base class
+ * @brief Single parameter functions abstract base class
  *
- * This class implements the abstract interface for a one parameter vector
- * function. A vector function is a function that returns a vector of values,
- * implemented by the GVector class.
+ * This class implements the abstract interface for a set of one parameter
+ * functions.
  *
- * The vector function is for example used for integration or numerical
+ * The set of functions is for example used for integration or numerical
  * computation of derivatives. This class has no members. The only pure
  * virtual method that needs to be implemented by the derived class is the
- * eval() method that provides vector function evaluation at a given value
- * x, e.g. y=eval(x).
+ * eval() method that evaluates the functions at a given value x and returns
+ * the evaluation result as an GNdarray object.
  ***************************************************************************/
 class GFunctions {
  
@@ -61,7 +60,7 @@ public:
     GFunctions& operator=(const GFunctions& functions);
  
     // Methods
-    virtual GVector eval(const double& x) = 0;
+    virtual GNdarray eval(const double& x) = 0;
  
 protected:
     // Protected methods
 /***************************************************************************
  *   GCTABackgroundPerfTable.hpp - CTA performance table background class  *
  * ----------------------------------------------------------------------- *
- *  copyright (C) 2014-2018 by Juergen Knoedlseder                         *
+ *  copyright (C) 2014-2020 by Juergen Knoedlseder                         *
  * ----------------------------------------------------------------------- *
  *                                                                         *
  *  This program is free software: you can redistribute it and/or modify   *
@@ -30,6 +30,7 @@
 /* __ Includes ___________________________________________________________ */
 #include <string>
 #include "GFilename.hpp"
+#include "GFunction.hpp"
 #include "GEnergies.hpp"
 #include "GNodeArray.hpp"
 #include "GModelSpectralNodes.hpp"
 /***************************************************************************
- *   GFunctions.i - Single parameter vector function abstract base class   *
+ *      GFunctions.i - Single parameter functions abstract base class      *
  * ----------------------------------------------------------------------- *
  *  copyright (C) 2020 by Juergen Knoedlseder                              *
  * ----------------------------------------------------------------------- *
@@ -20,13 +20,13 @@
  ***************************************************************************/
 /**
  * @file GFunctions.i
- * @brief Single parameter vector function abstract base class interface definition
+ * @brief Single parameter functions abstract base class definition
  * @author Juergen Knoedlseder
  */
 %{
 /* Put headers and other declarations here that are needed for compilation */
 #include "GFunctions.hpp"
-#include "GVector.hpp"
+#include "GNdarray.hpp"
 %}
  
  
@@ -43,5 +43,5 @@ public:
     virtual ~GFunction(void);
  
     // Methods
-    virtual GVector eval(const double& x) = 0;
+    virtual GNdarray eval(const double& x) = 0;
 };
 /***************************************************************************
- *  GFunctions.cpp - Single parameter vector function abstract base class  *
+ *     GFunctions.cpp - Single parameter functions abstract base class     *
  * ----------------------------------------------------------------------- *
  *  copyright (C) 2020 by Juergen Knoedlseder                              *
  * ----------------------------------------------------------------------- *
@@ -20,7 +20,7 @@
  ***************************************************************************/
 /**
  * @file GFunctions.cpp
- * @brief Single parameter vector function abstract base class implementation
+ * @brief Single parameter functions abstract base class implementation
  * @author Juergen Knoedlseder
  */
  
@@ -520,27 +520,30 @@ void TestGNumerics::test_function(void)
  ***************************************************************************/
 void TestGNumerics::test_functions(void)
 {
-    // Set vector
-    GVector sigma(1.0, 2.0, 4.0);
+    // Set sigma array
+    GNdarray sigma(1,3);
+    sigma(0,0) = 1.0;
+    sigma(0,1) = 2.0;
+    sigma(0,2) = 4.0;
  
     // Allocate functions
-    GaussVector functions(sigma);
+    GaussArray functions(sigma);
  
     // Evaluate functions for x=0
-    GVector result = functions.eval(0.0);
+    GNdarray result = functions.eval(0.0);
  
     // Test function values
-    test_value(result[0], 0.39894228, "Check function[0] value at x=0");
-    test_value(result[1], 0.19947114, "Check function[1] value at x=0");
-    test_value(result[2], 0.09973557, "Check function[2] value at x=0");
+    test_value(result(0,0), 0.39894228, "Check function[0] value at x=0");
+    test_value(result(0,1), 0.19947114, "Check function[1] value at x=0");
+    test_value(result(0,2), 0.09973557, "Check function[2] value at x=0");
  
     // Evaluate functions for x=1
     result = functions.eval(1.0);
  
     // Test function values
-    test_value(result[0], 0.24197072, "Check function[0] value at x=1");
-    test_value(result[1], 0.17603266, "Check function[1] value at x=1");
-    test_value(result[2], 0.09666703, "Check function[2] value at x=1");
+    test_value(result(0,0), 0.24197072, "Check function[0] value at x=1");
+    test_value(result(0,1), 0.17603266, "Check function[1] value at x=1");
+    test_value(result(0,2), 0.09666703, "Check function[2] value at x=1");
  
     // Exit test
     return;
@@ -53,24 +53,24 @@ protected:
  
  
 /***********************************************************************//**
- * @class GaussVector
+ * @class GaussArray
  *
- * @brief Gaussian vector function
+ * @brief Gaussian function array
  ***************************************************************************/
-class GaussVector : public GFunctions {
+class GaussArray : public GFunctions {
 public:
-    GaussVector(const GVector& sigma) : m_sigma(sigma) { return; }
-    virtual ~GaussVector(void) { return; }
-    GVector eval(const double& x) {
-        GVector val(m_sigma.size());
+    GaussArray(const GNdarray& sigma) : m_sigma(sigma) { return; }
+    virtual ~GaussArray(void) { return; }
+    GNdarray eval(const double& x) {
+        GNdarray val(m_sigma.shape());
         for (int i = 0; i < m_sigma.size(); ++i) {
-            double arg = -0.5*x*x/m_sigma[i]/m_sigma[i];
-            val[i]     = 1.0/std::sqrt(gammalib::twopi)/m_sigma[i] * std::exp(arg);
+            double arg = -0.5*x*x/m_sigma(i)/m_sigma(i);
+            val(i)     = 1.0/std::sqrt(gammalib::twopi)/m_sigma(i) * std::exp(arg);
         }
         return val;
     }
 protected:
-    GVector m_sigma;
+    GNdarray m_sigma;
 };