MnUserCovariance.h

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
 
/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/
 
#ifndef ROOT_Minuit2_MnUserCovariance
#define ROOT_Minuit2_MnUserCovariance
 
#include "Minuit2/MnConfig.h"
#include <vector>
#include <cassert>
 
namespace ROOT {
 
   namespace Minuit2 {
 
 
/**
   Class containing the covariance matrix data represented as a vector of
   size n*(n+1)/2
   Used to hide internal matrix representation to user
 */
class MnUserCovariance {
 
public:
 
  MnUserCovariance() : fData(std::vector<double>()), fNRow(0) {}
 
   // safe constructor using std::vector
  MnUserCovariance(const std::vector<double>& data, unsigned int nrow) :
    fData(data), fNRow(nrow) {
    assert(data.size() == nrow*(nrow+1)/2);
  }
 
   // unsafe constructor using just a pointer
  MnUserCovariance(const double * data, unsigned int nrow) :
     fData(std::vector<double>(data,data+nrow*(nrow+1)/2)),
     fNRow(nrow) {
  }
 
  MnUserCovariance(unsigned int n) :
    fData(std::vector<double>(n*(n+1)/2, 0.)), fNRow(n) {}
 
  ~MnUserCovariance() {}
 
  MnUserCovariance(const MnUserCovariance& cov) : fData(cov.fData), fNRow(cov.fNRow) {}
 
  MnUserCovariance& operator=(const MnUserCovariance& cov) {
    if(this != &cov) {
      fData = cov.fData;
      fNRow = cov.fNRow;
    }
    return *this;
  }
 
  double operator()(unsigned int row, unsigned int col) const {
    assert(row < fNRow && col < fNRow);
    if(row > col)
      return fData[col+row*(row+1)/2];
    else
      return fData[row+col*(col+1)/2];
  }
 
  double& operator()(unsigned int row, unsigned int col) {
    assert(row < fNRow && col < fNRow);
    if(row > col)
      return fData[col+row*(row+1)/2];
    else
      return fData[row+col*(col+1)/2];
  }
 
  void Scale(double f) {
    for(unsigned int i = 0; i < fData.size(); i++) fData[i] *= f;
  }
 
  const std::vector<double>& Data() const {return fData;}
 
  unsigned int Nrow() const {return fNRow;}
 
// VC 7.1 warning: conversion from size_t to unsigned int
  unsigned int size() const
  { return static_cast < unsigned int > ( fData.size() );
  }
 
private:
 
  std::vector<double> fData;
  unsigned int fNRow;
};
 
  }  // namespace Minuit2
 
}  // namespace ROOT
 
#endif  // ROOT_Minuit2_MnUserCovariance