LauComplex.hh

Go to the documentation of this file.

/*
Copyright 2004 University of Warwick

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/

/*****************************************************************************
 * 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