couplingconstant.h

/***************************************************************************
                          couplingconstant.h  -  description
                             -------------------
    author               : Armando Navarro-Vazquez
    email                : armando.deus@gmail.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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MAGNES_COUPLINGCONSTANT_H
#define MAGNES_COUPLINGCONSTANT_H

#include "coreexport.h"
#include "mathtools.h"
#include <vector>
namespace magnes
{

  class MAGNES_CORE_API Error
  {
  public:
    Error() :  m_value(0) {};
    ~Error() { delete m_value; }  
    double Value() const { return *m_value; }

    explicit Error(double v)
    {
      m_value =new double(v);
    }
    Error(const Error& e)
    {

        if (  e )
        {
          m_value = new double(e.Value());

        }
        else m_value=0;
        //   if (!m_value && !e)  //Do nothing

      
    }
    Error& operator = (const Error& e)
    {
      if ( &e != this)
      {
        if ( m_value && e )
        {
          *m_value=e.Value();

        }
        if ( m_value && !e)
        {
          delete m_value;
          m_value=0;
        }
        if ( !m_value && e)
        {
          m_value = new double(e.Value());

        }
        //   if (!m_value && !e)  //Do nothing

      }
      return *this;
    }


    Error& operator = (double v)
    {
      {
        if ( m_value ) *m_value=v;
        else
          m_value = new double(v);
      }
     return *this;
    }
  private:
    typedef void (Error::*bool_type) () const;
    void helperfunction() const {};
  private:
    //static unity m_unity;
    double* m_value;
public:
    operator bool_type () const
    {
       if ( m_value != 0 ) return &Error::helperfunction;
       else return 0;
    }

  };





class  MAGNES_CORE_API CouplingConstant
  {
    public:
    CouplingConstant(size_t i, size_t j);
    CouplingConstant(size_t i, size_t j, double ev);
    CouplingConstant(size_t i, size_t j, double ev,double err);
    double AverageValue() const { return _averagevalue; }
    double ExperimentalValue() const { return _experimentalvalue; }
    void SetExperimentalValue(double ev);
    bool HasExperimentalValue() const { return _hasexperimentalvalue; }
    void SetAverageValue(double v) { _averagevalue=v; }
    const std::vector<double>& ComputedValues() const { return _computedvalues; }
    std::vector<double>& ComputedValues() { return _computedvalues; }
    const size_t& I() const { return _first; }
    const size_t& J() const { return _second; }
    size_t& I() { return _first; }
    size_t& J() { return _second; }
    const magnes::Error& StandardDeviation() const { return _standarddeviation; }
    void SetStandardDeviation(double err) { _standarddeviation=err; }
    const std::vector<magnes::Error>& ComputedStandardDeviations() const { return _computederrors; }
    std::vector<magnes::Error>& ComputedStandardDeviations() { return _computederrors; }
    const magnes::Error& AveragedStandardDeviation() const { return _averagedstandarddeviation; }
    void SetAveragedStandardDeviation(double err) { _averagedstandarddeviation=err; }
   const std::vector< magnes::D1Array<double> >& Distribution() const { return _distribution; }
   std::vector< magnes::D1Array<double> >& Distribution() { return _distribution; }
   const magnes::D1Array<double>& AveragedDistribution() const { return _averageddistribution; }
   magnes::D1Array<double>& AveragedDistribution() { return _averageddistribution; }
   void ComputeStatistics();


private:
    size_t _first;
    size_t _second;
    std::vector<double> _computedvalues;
    double _averagevalue;
    double _experimentalvalue;
    bool _hasexperimentalvalue;
    magnes::Error _standarddeviation;
    magnes::Error _averagedstandarddeviation;
    std::vector<magnes::Error> _computederrors;
    std::vector< D1Array<double> > _distribution;
    D1Array<double> _averageddistribution;
  };   
    MAGNES_CORE_API bool operator==(const CouplingConstant &, const  CouplingConstant &);
    MAGNES_CORE_API std::ostream& operator << ( std::ostream& s,const CouplingConstant& c );
}

#endif