Spin.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                                  *
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef GW_SPIN_H
#define GW_Spin
#define GW_SPIN_H Gw_Spin

// GW includes
#ifndef GW_QNUMBER_H
#include "QNumber.h"
#endif

#ifndef GW_INFODATA_H
#include "InfoData.h"
#endif

// std includes
#include <iostream>

namespace Gw {

class Spin : public QNumber, public InfoData
{
public:
    //friend bool operator> (Spin &S1, Spin &S2);
    //friend bool operator<= (Spin &S1, Spin &S2);
    
    //friend bool operator< (Spin &S1, Spin &S2);
    //friend bool operator>= (Spin &S1, Spin &S2);
    
protected:
    Int_t fN; // numerator
    Int_t fD; // denominator - should be 1 or 2 for a spin
    
public:
    Spin();
    Spin(Int_t, Int_t);
    Spin(const Spin &spin): QNumber(spin), InfoData(spin) { fN = spin.fN; fD = spin.fD; }    
    virtual ~Spin();
    
    void Set(Int_t n, Int_t d = 1);
    Float_t Get() const;
    const Char_t* GetString() const;
    Bool_t IsHalfInt() const { return fD == 2; }
                
    Int_t GetN() const  { return fN; }
    Int_t GetD() const  { return fD; }
    
    Int_t GetInTwoHalfUnit() const
    {
        if ( fD == 1 )
            return 2*fN;
        return fN;
    }
                        
    virtual void Set(const char *s) ;    
        
    virtual Bool_t IsQNumber(QNumber::EQtype) const;

// some operators
    Spin& operator+=(Int_t value);
    Spin& operator++()
    {
        fN += fD;
        return *this;
    }
    Spin operator++(int)
    {
        Spin result(*this);
        operator++();
        return result;
    }
    Spin& operator--()
    {
        fN -= fD;
        return *this;
    }
    Spin operator--(int)
    {
        Spin result(*this);
        operator--();
        return result;
    }
    
    Spin operator - () const
    {
        Spin result(*this);
        result.Set(-fN,fD);
        
        return result;
    }

    Spin& operator+=(Spin sp);
    
    bool operator == (const Spin &s) const
    {
        if ( fN == s.fN && fD == s.fD )
                return true;

        return false;
    }
    bool operator<= (const Spin &s) const
    {
        if ( fN == s.fN && fD == s.fD )
            return true;
        
        return Get() <= s.Get();
    }
    bool operator< (const Spin &s) const
    {
        return Get() < s.Get();
    }
    bool operator>= (const Spin &s) const
    {
        if ( fN == s.fN && fD == s.fD )
            return true;
        
        return Get() >= s.Get();
    }
    bool operator> (const Spin &s) const
    {
        return Get() > s.Get();
    }
    
    ClassDef(Spin,1); // a Spin 
};
// inline members
inline Bool_t  Spin::IsQNumber(QNumber::EQtype t) const { return kSpin == t; }
inline Float_t Spin::Get() const { return Float_t(fN) / fD; }
    
//    friend bool operator> (Spin &S1, Spin &S2);
//inline bool operator<= (Spin &S1, Spin &S2){}
    
//    friend bool operator< (Spin &S1, Spin &S2);
//    friend bool operator>= (Spin &S1, Spin &S2);
}

std::ostream & operator << (std::ostream &, const Gw::Spin &);

#endif