Complete GOptimizerPars container.

Jürgen Knödlseder
1 parent f9774f2b
Showing 5 changed files with 407 additions and 33 deletions
ChangeLog
NEWS
include/GOptimizerPars.hpp
pyext/GOptimizerPars.i
src/opt/GOptimizerPars.cpp
-2013-12-13  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
+2013-12-19  Juergen Knoedlseder  <jurgen.knodlseder@irap.omp.eu>
  
         * Version 0.8.0 released
         ========================
@@ -19,6 +19,7 @@
         Add support for variable-length FITS columns
         Generalise GSkyPixel to 1D and 2D pixelisations
         Added King profile PSF for CTA
+        Reorganise GOptimizerPars class and add GOptimizerPar class
         Renamed the following classes:
         - GWcs => GSkyProjection
         - GWcslib => GWcs
@@ -2,7 +2,7 @@ New Features and Important Changes in GammaLib 00-08-00
  
 Author(s) : Juergen Knoedlseder
  
-13 December 2013
+19 December 2013
  
  
 1. Introduction
@@ -467,6 +467,15 @@ initialization problem of static variables and allow using of the
 GRegistryPointer smart pointer, removing memory leaks on exit of
 GammaLib.
  
+The GModels class no longer derives from GOptimizerPars, but now is
+a full-blown container deriving from GContainer. The pars() method
+has been added that returns an optimizer parameter container that
+holds all model parameters in a plain array.
+
+The GModelPar class now derives from GOptimizerPar. For the moment,
+the only methods that GModelPar implements with respect to
+GOptimizerPar are the XML read() and write() methods.
+
  
 9. Numerics module
 ------------------
@@ -492,7 +501,12 @@ objects.
  
 11. Optimization module
 -----------------------
-None
+Introduce the GOptimizerPar class to represent a general parameter of
+the optimizer function. The class was essentially copied from GModelPar.
+GModelPar now derives from this class.
+
+The GOptimizerPars is now a full blown container class that holds
+GOptimizerPar objects.
  
  
 12. Sky module
@@ -29,6 +29,7 @@
  
 /* __ Includes ___________________________________________________________ */
 #include <string>
+#include <vector>
 #include "GContainer.hpp"
 #include "GOptimizerPar.hpp"
  
@@ -64,15 +65,26 @@ public:
     const GOptimizerPar* operator[](const std::string& name) const;
  
     // Methods
-    void            clear(void);
-    GOptimizerPars* clone(void) const;
-    int             size(void) const;
-    bool            isempty(void) const;
-    int             nfree(void) const;
-    void            attach(GOptimizerPar *par);
-    void            remove(const int& index);
-    void            reserve(const int& num);
-    std::string     print(const GChatter& chatter = NORMAL) const;
+    void                 clear(void);
+    GOptimizerPars*      clone(void) const;
+    GOptimizerPar*       at(const int& index);
+    const GOptimizerPar* at(const int& index) const;
+    int                  size(void) const;
+    bool                 isempty(void) const;
+    int                  nfree(void) const;
+    GOptimizerPar*       set(const int& index, const GOptimizerPar& par);
+    GOptimizerPar*       set(const std::string& name, const GOptimizerPar& par);
+    void                 attach(GOptimizerPar* par);
+    void                 attach(const int& index, GOptimizerPar* par);
+    void                 attach(const std::string& name, GOptimizerPar* par);
+    GOptimizerPar*       insert(const int& index, const GOptimizerPar& par);
+    GOptimizerPar*       insert(const std::string& name, const GOptimizerPar& par);
+    void                 remove(const int& index);
+    void                 remove(const std::string& name);
+    void                 reserve(const int& num);
+    void                 extend(const GOptimizerPars& pars);
+    bool                 contains(const std::string& name) const;
+    std::string          print(const GChatter& chatter = NORMAL) const;
  
 protected:
     // Protected methods
@@ -88,11 +100,12 @@ protected:
  
  
 /***********************************************************************//**
- * @brief Return pointer to model
+ * @brief Return pointer to parameter
  *
- * @param[in] index Model index [0,...,size()-1].
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @return Pointer to parameter.
  *
- * Returns a pointer to the model with the specified @p index.
+ * Returns a pointer to the parameter with the specified @p index.
  ***************************************************************************/
 inline
 GOptimizerPar* GOptimizerPars::operator[](const int& index)
@@ -102,11 +115,12 @@ GOptimizerPar* GOptimizerPars::operator[](const int&amp; index)
  
  
 /***********************************************************************//**
- * @brief Return pointer to model (const version)
+ * @brief Return pointer to parameter (const version)
  *
- * @param[in] index Model index [0,...,size()-1].
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @return Pointer to parameter.
  *
- * Returns a const pointer to the model with the specified @p index.
+ * Returns a pointer to the parameter with the specified @p index.
  ***************************************************************************/
 inline
 const GOptimizerPar* GOptimizerPars::operator[](const int& index) const
@@ -116,11 +130,11 @@ const GOptimizerPar* GOptimizerPars::operator[](const int&amp; index) const
  
  
 /***********************************************************************//**
- * @brief Return number of models in container
+ * @brief Return number of parameters in container
  *
- * @return Number of models in container.
+ * @return Number of parameters in container.
  *
- * Returns the number of models in the model container.
+ * Returns the number of parameters in the parameter container.
  ***************************************************************************/
 inline
 int GOptimizerPars::size(void) const
@@ -130,11 +144,11 @@ int GOptimizerPars::size(void) const
  
  
 /***********************************************************************//**
- * @brief Signals if there are no models in container
+ * @brief Signals if there are no parameters in container
  *
  * @return True if container is empty, false otherwise.
  *
- * Signals if the model container does not contain any model.
+ * Signals if the parameters container does not contain any parameter.
  ***************************************************************************/
 inline
 bool GOptimizerPars::isempty(void) const
@@ -144,11 +158,11 @@ bool GOptimizerPars::isempty(void) const
  
  
 /***********************************************************************//**
- * @brief Reserves space for models in container
+ * @brief Reserves space for parameters in container
  *
- * @param[in] num Number of models
+ * @param[in] num Number of parameters.
  *
- * Reserves space for @p num models in the container.
+ * Reserves space for @p num parameters in the container.
  ***************************************************************************/
 inline
 void GOptimizerPars::reserve(const int& num)
@@ -45,12 +45,22 @@ public:
     // Methods
     void            clear(void);
     GOptimizerPars* clone(void) const;
+    GOptimizerPar*  at(const int& index);
     int             size(void) const;
     bool            isempty(void) const;
     int             nfree(void) const;
+    GOptimizerPar*  set(const int& index, const GOptimizerPar& par);
+    GOptimizerPar*  set(const std::string& name, const GOptimizerPar& par);
     void            attach(GOptimizerPar *par);
+    void            attach(const int& index, GOptimizerPar* par);
+    void            attach(const std::string& name, GOptimizerPar* par);
+    GOptimizerPar*  insert(const int& index, const GOptimizerPar& par);
+    GOptimizerPar*  insert(const std::string& name, const GOptimizerPar& par);
     void            remove(const int& index);
+    void            remove(const std::string& name);
     void            reserve(const int& num);
+    void            extend(const GOptimizerPars& pars);
+    bool            contains(const std::string& name) const;
 };
  
  
@@ -70,10 +80,9 @@ public:
     GOptimizerPar* __getitem__(const std::string& name) {
         return (*self)[name];
     }
-/*
-    void __setitem__(const int& index, const GOptimizerPar& val) {
+    void __setitem__(const int& index, GOptimizerPar* par) {
         if (index >= 0 && index < self->size()) {
-            self->set(index, val);
+            self->attach(index, par);
             return;
         }
         else {
@@ -81,11 +90,10 @@ public:
                                            index, self->size());
         }
     }
-    void __setitem__(const std::string& name, const GOptimizerPar& val) {
-        self->set(name, val);
+    void __setitem__(const std::string& name, GOptimizerPar* par) {
+        self->attach(name, par);
         return;
     }
-*/
     GOptimizerPars copy() {
         return (*self);
     }
@@ -34,7 +34,16 @@
  
 /* __ Method name definitions ____________________________________________ */
 #define G_ACCESS                   "GOptimizerPars::operator[](std::string&)"
+#define G_AT1                                      "GOptimizerPars::at(int&)"
+#define G_AT2                              "GOptimizerPars::at(std::string&)"
+#define G_SET1                    "GOptimizerPars::set(int&, GOptimizerPar&)"
+#define G_SET2            "GOptimizerPars::set(std::string&, GOptimizerPar&)"
+#define G_ATTACH1              "GOptimizerPars::attach(int&, GOptimizerPar*)"
+#define G_ATTACH2      "GOptimizerPars::attach(std::string&, GOptimizerPar*)"
+#define G_INSERT1              "GOptimizerPars::insert(int&, GOptimizerPar&)"
+#define G_INSERT2      "GOptimizerPars::insert(std::string&, GOptimizerPar&)"
 #define G_REMOVE1                              "GOptimizerPars::remove(int&)"
+#define G_REMOVE2                      "GOptimizerPars::remove(std::string&)"
  
  
 /* __ Macros _____________________________________________________________ */
@@ -242,6 +251,56 @@ GOptimizerPars* GOptimizerPars::clone(void) const
  
  
 /***********************************************************************//**
+ * @brief Return pointer to parameter
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @return Pointer to parameter.
+ *
+ * @exception GException::out_of_range
+ *            Extension number is out of range.
+ *
+ * Returns a pointer to the parameter with the specified @p index.
+ ***************************************************************************/
+GOptimizerPar* GOptimizerPars::at(const int& index)
+{
+    // Compile option: raise an exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_AT1, "Parameter index", index, size());
+    }
+    #endif
+
+    // Return pointer
+    return (m_pars[index]);
+}
+
+
+/***********************************************************************//**
+ * @brief Return pointer to parameter (const version)
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @return Pointer to parameter.
+ *
+ * @exception GException::out_of_range
+ *            Extension number is out of range.
+ *
+ * Returns a pointer to the parameter with the specified @p index.
+ ***************************************************************************/
+const GOptimizerPar* GOptimizerPars::at(const int& index) const
+{
+    // Compile option: raise an exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_AT1, "Parameter index", index, size());
+    }
+    #endif
+
+    // Return pointer
+    return (m_pars[index]);
+}
+
+
+/***********************************************************************//**
  * @brief Return number of free parameters
  *
  * @return Number of free parameters.
@@ -267,11 +326,77 @@ int GOptimizerPars::nfree(void) const
  
  
 /***********************************************************************//**
+ * @brief Set parameter in container
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @param[in] par Parameter.
+ * @return Pointer to deep copy of parameter.
+ *
+ * @exception GException::out_of_range
+ *            Parameter index is out of range.
+ *
+ * Set parameter in the container. A deep copy of the parameter will be made.
+ ***************************************************************************/
+GOptimizerPar* GOptimizerPars::set(const int& index, const GOptimizerPar& par)
+{
+    // Compile option: raise an exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_SET1, "Parameter index", index, size());
+    }
+    #endif
+
+    // Delete parameter if it has been allocated
+    if (m_alloc[index]) {
+        delete m_pars[index];
+    }
+
+    // Clone parameter
+    GOptimizerPar* ptr = par.clone();
+
+    // Set parameter
+    m_alloc[index] = true;
+    m_pars[index]  = ptr;
+
+    // Return parameter pointer
+    return ptr;
+}
+
+
+/***********************************************************************//**
+ * @brief Set parameter in container
+ *
+ * @param[in] name Parameter name.
+ * @param[in] par Parameter.
+ * @return Pointer to deep copy of parameter.
+ *
+ * @exception GException::invalid_argument
+ *            Specified parameter @p name not found in container.
+ ***************************************************************************/
+GOptimizerPar* GOptimizerPars::set(const std::string& name, const GOptimizerPar& par)
+{
+    // Get parameter index
+    int index = get_index(name);
+
+    // Throw exception if model name was not found
+    if (index == -1) {
+        std::string msg = "Parameter \""+name+"\" not found in parameter"
+                          " container.\nPlease specify a valid parameter"
+                          " name.";
+        throw GException::invalid_argument(G_SET2, msg);
+    }
+
+    // Set parameter
+    return set(index, par);
+}
+
+
+/***********************************************************************//**
  * @brief Attach parameter to container
  *
  * @param[in] par Parameter pointer.
  ***************************************************************************/
-void GOptimizerPars::attach(GOptimizerPar *par)
+void GOptimizerPars::attach(GOptimizerPar* par)
 {
     // Push pointer in vector if it is valid
     if (par != NULL) {
@@ -285,6 +410,134 @@ void GOptimizerPars::attach(GOptimizerPar *par)
  
  
 /***********************************************************************//**
+ * @brief Attach parameter to container at the specified index
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @param[in] par Parameter pointer.
+ *
+ * @exception GException::out_of_range
+ *            Parameter @p index is not valid.
+ *
+ * Attaches parameter pointer at the specified @p index.
+ ***************************************************************************/
+void GOptimizerPars::attach(const int& index, GOptimizerPar* par)
+{
+    // Compile option: raise an exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_ATTACH1, "Parameter index", index, size());
+    }
+    #endif
+
+    // Delete parameter if it has been allocated
+    if (m_alloc[index]) {
+        delete m_pars[index];
+    }
+
+    // Set parameter
+    m_alloc[index] = false;
+    m_pars[index]  = par;
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Attach parameter to container at the specified index
+ *
+ * @param[in] name Parameter name.
+ * @param[in] par Parameter pointer.
+ *
+ * @exception GException::out_of_range
+ *            Parameter @p index is not valid.
+ *
+ * Attaches parameter pointer at the specified @p index.
+ ***************************************************************************/
+void GOptimizerPars::attach(const std::string& name, GOptimizerPar* par)
+{
+    // Get parameter index
+    int index = get_index(name);
+
+    // Throw exception if model name was not found
+    if (index == -1) {
+        std::string msg = "Parameter \""+name+"\" not found in parameter"
+                          " container.\nPlease specify a valid parameter"
+                          " name.";
+        throw GException::invalid_argument(G_ATTACH2, msg);
+    }
+
+    // Remove parameter
+    attach(index, par);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Insert parameter into container
+ *
+ * @param[in] index Parameter index [0,...,size()-1].
+ * @param[in] par Parameter.
+ * @return Pointer to deep copy of parameter.
+ *
+ * @exception GException::out_of_range
+ *            Parameter index is out of range.
+ *
+ * Set parameter in the container. A deep copy of the parameter will be made.
+ ***************************************************************************/
+GOptimizerPar* GOptimizerPars::insert(const int& index, const GOptimizerPar& par)
+{
+    // Compile option: raise an exception if index is out of range
+    #if defined(G_RANGE_CHECK)
+    if (index < 0 || index >= size()) {
+        throw GException::out_of_range(G_INSERT1, "Parameter index", index, size());
+    }
+    #endif
+
+    // Clone parameter
+    GOptimizerPar* ptr = par.clone();
+
+    // Inserts deep copy of parameter
+    m_alloc.insert(m_alloc.begin()+index, true);
+    m_pars.insert(m_pars.begin()+index, ptr);
+
+    // Return parameter pointer
+    return ptr;
+}
+
+
+/***********************************************************************//**
+ * @brief Insert parameter into container
+ *
+ * @param[in] name Parameter name.
+ * @param[in] par Parameter.
+ * @return Pointer to deep copy of parameter.
+ *
+ * @exception GException::invalid_argument
+ *            Specified parameter @p name not found in container.
+ ***************************************************************************/
+GOptimizerPar* GOptimizerPars::insert(const std::string& name,
+                                      const GOptimizerPar& par)
+{
+    // Get parameter index
+    int index = get_index(name);
+
+    // Throw exception if model name was not found
+    if (index == -1) {
+        std::string msg = "Parameter \""+name+"\" not found in parameter"
+                          " container.\nPlease specify a valid parameter"
+                          " name.";
+        throw GException::invalid_argument(G_INSERT2, msg);
+    }
+
+    // Insert parameter
+    return insert(index, par);
+}
+
+
+/***********************************************************************//**
  * @brief Remove parameter from container
  *
  * @param[in] index Parameter index [0,...,size()-1].
@@ -319,6 +572,90 @@ void GOptimizerPars::remove(const int&amp; index)
  
  
 /***********************************************************************//**
+ * @brief Remove parameter from container
+ *
+ * @param[in] name Parameter name.
+ *
+ * @exception GException::invalid_argument
+ *            Specified parameter @p name not found in container.
+ ***************************************************************************/
+void GOptimizerPars::remove(const std::string& name)
+{
+    // Get parameter index
+    int index = get_index(name);
+
+    // Throw exception if model name was not found
+    if (index == -1) {
+        std::string msg = "Parameter \""+name+"\" not found in parameter"
+                          " container.\nPlease specify a valid parameter"
+                          " name.";
+        throw GException::invalid_argument(G_REMOVE2, msg);
+    }
+
+    // Remove parameter
+    remove(index);
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Append parameter container
+ *
+ * @param[in] pars Parameter container.
+ *
+ * Append parameter container to the container. All parameters that were
+ * allocated within @p pars will be clones, for the other parameters, the
+ * pointers will be copied.
+ ***************************************************************************/
+void GOptimizerPars::extend(const GOptimizerPars& pars)
+{
+    // Do nothing if parameter container is empty
+    if (!pars.isempty()) {
+
+        // Get size. Note that we extract the size first to avoid an
+        // endless loop that arises when a container is appended to
+        // itself.
+        int num = pars.size();
+
+        // Reserve enough space
+        reserve(size() + num);
+
+        // Loop over all parameters 
+        for (int i = 0; i < num; ++i) {
+            GOptimizerPar* par = (pars.m_alloc[i]) ? pars.m_pars[i]->clone()
+                                                   : pars.m_pars[i];
+            m_pars.push_back(par);
+        }
+
+    } // endif: parameter container was not empty
+    
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Signals if parameter name exists
+ *
+ * @param[in] name Parameter name.
+ * @return True if parameter with specified @p name exists.
+ *
+ * Searches all parameter names for a match with the specified @p name. If
+ * the specified name has been found, true is returned.
+ ***************************************************************************/
+bool GOptimizerPars::contains(const std::string& name) const
+{
+    // Get model index
+    int index = get_index(name);
+
+    // Return
+    return (index != -1);
+}
+
+
+/***********************************************************************//**
  * @brief Print parameters
  *
  * @param[in] chatter Chattiness (defaults to NORMAL).