LauComplex.hh

Go to the documentation of this file.

// Copyright University of Warwick 2004 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Authors:
// Thomas Latham
// John Back
// Paul Harrison

/*****************************************************************************
 * Class based on RooFit/RooComplex.                                         *
 * Original copyright given below.                                           *
 *****************************************************************************
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/

#ifndef LAU_COMPLEX
#define LAU_COMPLEX

#include <iosfwd>

#include "TMath.h"


class LauComplex {

        public:
                inline LauComplex() : re_(0.0), im_(0.0) {}


                inline LauComplex(Double_t a, Double_t b) : re_(a), im_(b) {}

                virtual ~LauComplex() {}


                inline LauComplex(const LauComplex& other) : re_(other.re_), im_(other.im_) {}


                inline LauComplex& operator=(const LauComplex& other)
                {
                        if ( &other != this ) {
                                re_ = other.re_;
                                im_ = other.im_;
                        }
                        return *this;
                }


                inline LauComplex operator-() const
                {
                        return LauComplex(-re_,-im_);
                }


                inline LauComplex operator+(const LauComplex& other) const
                {
                        LauComplex tmpCmplx( *this );
                        tmpCmplx += other;
                        return tmpCmplx;
                }


                inline LauComplex operator-(const LauComplex& other) const
                {
                        LauComplex tmpCmplx( *this );
                        tmpCmplx -= other;
                        return tmpCmplx;
                }


                inline LauComplex operator*(const LauComplex& other) const
                {
                        LauComplex tmpCmplx( *this );
                        tmpCmplx *= other;
                        return tmpCmplx;
                }


                inline LauComplex operator/(const LauComplex& other) const
                {
                        LauComplex tmpCmplx( *this );
                        tmpCmplx /= other;
                        return tmpCmplx;
                }


                inline LauComplex operator+=(const LauComplex& other)
                {
                        this->re_ += other.re_;
                        this->im_ += other.im_;
                        return (*this);
                }


                inline LauComplex operator-=(const LauComplex& other)
                {
                        this->re_ -= other.re_;
                        this->im_ -= other.im_;
                        return (*this);
                }


                inline LauComplex operator*=(const LauComplex& other)
                {
                        Double_t realPart = this->re_*other.re_ - this->im_*other.im_;
                        Double_t imagPart = this->re_*other.im_ + this->im_*other.re_;
                        this->setRealImagPart( realPart, imagPart );
                        return (*this);
                }


                inline LauComplex operator/=(const LauComplex& other)
                {
                        Double_t x(other.abs2());
                        Double_t realPart = (this->re_*other.re_ + this->im_*other.im_)/x;
                        Double_t imagPart = (this->im_*other.re_ - this->re_*other.im_)/x;
                        this->setRealImagPart( realPart, imagPart );
                        return (*this);
                }


                inline Bool_t operator==(const LauComplex& other) const
                {
                        return (re_==other.re_ && im_==other.im_) ;
                }


                inline Double_t re() const
                {
                        return re_;
                }


                inline Double_t im() const
                {
                        return im_;
                }


                inline Double_t abs() const
                {
                        return TMath::Sqrt( this->abs2() );
                }


                inline Double_t abs2() const
                {
                        return re_*re_ + im_*im_;
                }


                inline Double_t arg() const
                {
                        return TMath::ATan2( im_, re_ );
                }


                inline LauComplex exp() const
                {
                        Double_t mag(TMath::Exp(re_));
                        return LauComplex(mag*TMath::Cos(im_),mag*TMath::Sin(im_));
                }


                inline LauComplex conj() const
                {
                        return LauComplex(re_,-im_);
                } 

                inline void makeConj()
                {
                        im_ = -im_;
                }


                inline LauComplex scale(Double_t scaleVal) const
                {
                        return LauComplex(scaleVal*re_, scaleVal*im_);
                }


                inline void rescale(Double_t scaleVal)
                {
                        re_ *= scaleVal;
                        im_ *= scaleVal;
                }


                inline void setRealPart(Double_t realpart)
                {
                        re_ = realpart;
                }


                inline void setImagPart(Double_t imagpart)
                {
                        im_ = imagpart;
                }


                inline void setRealImagPart(Double_t realpart, Double_t imagpart)
                {
                        this->setRealPart( realpart );
                        this->setImagPart( imagpart );
                }

                inline void zero()
                {
                        this->setRealImagPart(0.0,0.0);
                }

                void print() const;

        private:
                Double_t re_;
                Double_t im_;

                ClassDef(LauComplex,0) // a non-persistent bare-bones complex class
};

std::istream& operator>>(std::istream& os, LauComplex& z);
std::ostream& operator<<(std::ostream& os, const LauComplex& z);

#endif