+

class TComplex

-

library: libMathCore
#include "TComplex.h"

Display options:

[ ↑ Top ] | [ ? Help ]

Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file viewVC header viewVC source

Sections: class description function members data members class charts

ROOT » MATH » MATHCORE » TComplex

class TComplex

TComplex

Function Members (Methods)

public:

	TComplex()
	TComplex(const TComplex&)
	TComplex(Double_t re, Double_t im = 0, Bool_t polar = kFALSE)
virtual	~TComplex()
static Double_t	Abs(const TComplex& c)
static TComplex	ACos(const TComplex& c)
static TComplex	ACosH(const TComplex& c)
static TComplex	ASin(const TComplex& c)
static TComplex	ASinH(const TComplex& c)
static TComplex	ATan(const TComplex& c)
static TComplex	ATanH(const TComplex& c)
static TClass*	Class()
static TComplex	Conjugate(const TComplex& c)
static TComplex	Cos(const TComplex& c)
static TComplex	CosH(const TComplex& c)
static TComplex	Exp(const TComplex& c)
static Int_t	Finite(const TComplex& c)
static TComplex	I()
Double_t	Im() const
virtual TClass*	IsA() const
static Int_t	IsNaN(const TComplex& c)
static TComplex	Log(const TComplex& c)
static TComplex	Log10(const TComplex& c)
static TComplex	Log2(const TComplex& c)
static TComplex	Max(const TComplex& a, const TComplex& b)
static TComplex	Min(const TComplex& a, const TComplex& b)
static TComplex	Normalize(const TComplex& c)
static TComplex	One()
Double_t	operator Double_t() const
Float_t	operator Float_t() const
Int_t	operator Int_t() const
TComplex	operator()(Double_t x, Double_t y, Bool_t polar = kFALSE)
TComplex	operator*(const TComplex& c) const
TComplex	operator*(Double_t c) const
TComplex	operator*=(const TComplex& c)
TComplex	operator+()
TComplex	operator+(const TComplex& c) const
TComplex	operator+(Double_t c) const
TComplex	operator+=(const TComplex& c)
TComplex	operator-()
TComplex	operator-(const TComplex& c) const
TComplex	operator-(Double_t c) const
TComplex	operator-=(const TComplex& c)
TComplex	operator/(const TComplex& c) const
TComplex	operator/(Double_t c) const
TComplex	operator/=(const TComplex& c)
TComplex&	operator=(const TComplex&)
static TComplex	Power(const TComplex& x, const TComplex& y)
static TComplex	Power(const TComplex& x, Double_t y)
static TComplex	Power(Double_t x, const TComplex& y)
static TComplex	Power(const TComplex& x, Int_t y)
static TComplex	Range(const TComplex& lb, const TComplex& ub, const TComplex& c)
Double_t	Re() const
Double_t	Rho() const
Double_t	Rho2() const
virtual void	ShowMembers(TMemberInspector& insp, char* parent)
static TComplex	Sin(const TComplex& c)
static TComplex	SinH(const TComplex& c)
static TComplex	Sqrt(const TComplex& c)
virtual void	Streamer(TBuffer& b)
void	StreamerNVirtual(TBuffer& b)
static TComplex	Tan(const TComplex& c)
static TComplex	TanH(const TComplex& c)
Double_t	Theta() const

Data Members

protected:

Double_t	fIm	imaginary part
Double_t	fRe	real part

Class Charts

Inheritance Inherited Members Includes Libraries

Class Charts

Function documentation

TComplex(Double_t re, Double_t im = 0, Bool_t polar = kFALSE)

 Standard constructor

 ctors and dtors

{}

TComplex(Double_t re, Double_t im = 0, Bool_t polar = kFALSE)

virtual ~TComplex()

{}

 constants

{return TComplex(0,1);}

{return TComplex(1,0);}

Double_t Re() const

 getters and setters

{return fRe;}

Double_t Im() const

{return fIm;}

Double_t Rho() const

{return TMath::Sqrt(fRe*fRe+fIm*fIm);}

Double_t Rho2() const

{return fRe*fRe+fIm*fIm;}

Double_t Theta() const

{return (fIm||fRe)?TMath::ATan2(fIm,fRe):0;}

TComplex operator()(Double_t x, Double_t y, Bool_t polar = kFALSE)

operator Double_t() const

 Convertors

{return fRe;}

operator Float_t() const

{return static_cast<Float_t>(fRe);}

operator Int_t() const

{return static_cast<Int_t>(fRe);}

TComplex Sqrt(const TComplex& c)

 TMath:: extensions

{return TComplex(TMath::Sqrt(c.Rho()),0.5*c.Theta(),kTRUE);}

TComplex Exp(const TComplex& c)

{return TComplex(TMath::Exp(c.fRe),c.fIm,kTRUE);}

TComplex Log(const TComplex& c)

{return TComplex(0.5*TMath::Log(c.Rho2()),c.Theta());}

TComplex Log2(const TComplex& c)

{return Log(c)/TMath::Log(2);}

TComplex Log10(const TComplex& c)

{return Log(c)/TMath::Log(10);}

TComplex Sin(const TComplex& c)

Cos(const TComplex& c)

TComplex Tan(const TComplex& c)

{TComplex cc=Cos(c); return Sin(c)*Conjugate(cc)/cc.Rho2();}

TComplex ASin(const TComplex& c)

{return -I()*Log(I()*c+TMath::Sign(1.,c.Im())*Sqrt(1.-c*c));}

TComplex ACos(const TComplex& c)

{return -I()*Log(c+TMath::Sign(1.,c.Im())*Sqrt(c*c-1.));}

TComplex ATan(const TComplex& c)

{return -0.5*I()*Log((1.+I()*c)/(1.-I()*c));}

TComplex SinH(const TComplex& c)

CosH(const TComplex& c)

TComplex TanH(const TComplex& c)

{TComplex cc=CosH(c); return SinH(c)*Conjugate(cc)/cc.Rho2();}

TComplex ASinH(const TComplex& c)

{return Log(c+TMath::Sign(1.,c.Im())*Sqrt(c*c+1.));}

TComplex ACosH(const TComplex& c)

{return Log(c+TMath::Sign(1.,c.Im())*Sqrt(c*c-1.));}

TComplex ATanH(const TComplex& c)

{return 0.5*Log((1.+c)/(1.-c));}

Double_t Abs(const TComplex& c)

{return c.Rho();}

TComplex Power(const TComplex& x, const TComplex& y)

TComplex Power(const TComplex& x, Double_t y)

{return TComplex(TMath::Power(x.Rho(),y),x.Theta()*y,kTRUE);}

TComplex Power(Double_t x, const TComplex& y)

TComplex Power(const TComplex& x, Int_t y)

{return TComplex(TMath::Power(x.Rho(),y),x.Theta()*y,kTRUE);}

Int_t Finite(const TComplex& c)

{return TMath::Min(TMath::Finite(c.Re()),TMath::Finite(c.Im()));}

Int_t IsNaN(const TComplex& c)

{return TMath::Max(TMath::IsNaN(c.Re()),TMath::IsNaN(c.Im()));}

TComplex Min(const TComplex& a, const TComplex& b)

{return a.Rho()<=b.Rho()?a:b;}

TComplex Max(const TComplex& a, const TComplex& b)

{return a.Rho()>=b.Rho()?a:b;}

TComplex Normalize(const TComplex& c)

{return TComplex(1.,c.Theta(),kTRUE);}

TComplex Conjugate(const TComplex& c)

{return TComplex(c.Re(),-c.Im());}

TComplex Range(const TComplex& lb, const TComplex& ub, const TComplex& c)

{return Max(lb,Min(c,ub));}