simpleDescriptors.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// 
 
#ifndef BALL_QSAR_SIMPLEDESCRIPTORS_H
#define BALL_QSAR_SIMPLEDESCRIPTORS_H
 
#ifndef BALL_QSAR_SIMPLEBASE_H
# include <BALL/QSAR/simpleBase.h>
#endif
 
namespace BALL
{
  // 40 simple descriptors

  class BALL_EXPORT MolecularWeight
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(MolecularWeight)
 
    
    
    MolecularWeight();

    MolecularWeight(const MolecularWeight& mw);

    virtual ~MolecularWeight();


    MolecularWeight& operator = (const MolecularWeight& mw);
  };

  class BALL_EXPORT NumberOfBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfBonds)
 
    
    
    NumberOfBonds();

    NumberOfBonds(const NumberOfBonds& nb);

    virtual ~NumberOfBonds();


    NumberOfBonds& operator = (const NumberOfBonds& nb);
  };

  class BALL_EXPORT NumberOfSingleBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfSingleBonds)
 
    

    NumberOfSingleBonds();

    NumberOfSingleBonds(const NumberOfSingleBonds& nsb);

    virtual ~NumberOfSingleBonds();


    NumberOfSingleBonds& operator = (const NumberOfSingleBonds& nsb);
  };

  class BALL_EXPORT NumberOfDoubleBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfDoubleBonds)
 
    

    NumberOfDoubleBonds();

    NumberOfDoubleBonds(const NumberOfDoubleBonds& ndb);

    virtual ~NumberOfDoubleBonds();


    NumberOfDoubleBonds& operator = (const NumberOfDoubleBonds& ndb);
  };

  class BALL_EXPORT NumberOfTripleBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfTripleBonds)
 
    

    NumberOfTripleBonds();

    NumberOfTripleBonds(const NumberOfTripleBonds& ntb);

    virtual ~NumberOfTripleBonds();


    NumberOfTripleBonds& operator = (const NumberOfTripleBonds& ntb);
  };

  class BALL_EXPORT NumberOfAromaticBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfAromaticBonds)
 
    

    NumberOfAromaticBonds();

    NumberOfAromaticBonds(const NumberOfAromaticBonds& nab);

    virtual ~NumberOfAromaticBonds();


    NumberOfAromaticBonds& operator = (const NumberOfAromaticBonds& nab);
  };

  class BALL_EXPORT NumberOfAtoms
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfAtoms)
 
    

    NumberOfAtoms();

    NumberOfAtoms(const NumberOfAtoms& na);

    virtual ~NumberOfAtoms();


    NumberOfAtoms& operator = (const NumberOfAtoms& na);
  };

  class BALL_EXPORT NumberOfBoron
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfBoron)
 
    

    NumberOfBoron();
    
    NumberOfBoron(const NumberOfBoron& nb);

    virtual ~NumberOfBoron();


    NumberOfBoron& operator = (const NumberOfBoron& nb);
  };

  class BALL_EXPORT NumberOfCarbon
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfCarbon)
 
    

    NumberOfCarbon();

    NumberOfCarbon(const NumberOfCarbon& nc);

    virtual ~NumberOfCarbon();


    NumberOfCarbon& operator = (const NumberOfCarbon& nc);
  };

  class BALL_EXPORT NumberOfNitrogen
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfNitrogen)
 
    

    NumberOfNitrogen();

    NumberOfNitrogen(const NumberOfNitrogen& nn);

    virtual ~NumberOfNitrogen();


    NumberOfNitrogen& operator = (const NumberOfNitrogen& nn);
  };

  class BALL_EXPORT NumberOfOxygen
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfOxygen)
 
    

    NumberOfOxygen();

    NumberOfOxygen(const NumberOfOxygen& no);

    virtual ~NumberOfOxygen();


    NumberOfOxygen& operator = (const NumberOfOxygen& no);
  };

  class BALL_EXPORT NumberOfFlourine
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfFlourine)
 
    

    NumberOfFlourine();

    NumberOfFlourine(const NumberOfFlourine& nf);

    virtual ~NumberOfFlourine();


    NumberOfFlourine& operator = (const NumberOfFlourine& nf);
  };

  class BALL_EXPORT NumberOfPhosphorus
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfPhosphorus)
 
    

    NumberOfPhosphorus();

    NumberOfPhosphorus(const NumberOfPhosphorus& np);
    
    virtual ~NumberOfPhosphorus();
  
    //7
    NumberOfPhosphorus& operator = (const NumberOfPhosphorus& np);
  };

  class BALL_EXPORT NumberOfSulfur
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfSulfur)
 
    

    NumberOfSulfur();

    NumberOfSulfur(const NumberOfSulfur& ns);

    virtual ~NumberOfSulfur();


    NumberOfSulfur& operator = (const NumberOfSulfur& ns);
  };

  class BALL_EXPORT NumberOfChlorine
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfChlorine)
 
    

    NumberOfChlorine();

    NumberOfChlorine(const NumberOfChlorine& nc);

    virtual ~NumberOfChlorine();


    NumberOfChlorine& operator = (const NumberOfChlorine& nc);
  };

  class BALL_EXPORT NumberOfBromine
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfBromine)
 
    

    NumberOfBromine();

    NumberOfBromine(const NumberOfBromine& nb);

    virtual ~NumberOfBromine();


    NumberOfBromine& operator = (const NumberOfBromine& nb);
  };

  class BALL_EXPORT NumberOfIodine
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfIodine)
 
    

    NumberOfIodine();

    NumberOfIodine(const NumberOfIodine& ni);

    virtual ~NumberOfIodine();


    NumberOfIodine& operator = (const NumberOfIodine& ni);
  };

  class BALL_EXPORT NumberOfHydrogen
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfHydrogen)
 
    

    NumberOfHydrogen();

    NumberOfHydrogen(const NumberOfHydrogen& nh);

    virtual ~NumberOfHydrogen();


    NumberOfHydrogen& operator = (const NumberOfHydrogen& nh);
  };

  class BALL_EXPORT FormalCharge
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(FormalCharge)
 
    

    FormalCharge();

    FormalCharge(const FormalCharge& fc);

    virtual ~FormalCharge();


    FormalCharge& operator = (const FormalCharge& fc);
  };

  class BALL_EXPORT NumberOfHeavyAtoms
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfHeavyAtoms)
 
    

    NumberOfHeavyAtoms();

    NumberOfHeavyAtoms(const NumberOfHeavyAtoms& nha);

    virtual ~NumberOfHeavyAtoms();


    NumberOfHeavyAtoms& operator = (const NumberOfHeavyAtoms& nha);
  };
  
  class BALL_EXPORT MeanAtomInformationContent
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(MeanAtomInformationContent)
 
    

    MeanAtomInformationContent();

    MeanAtomInformationContent(const MeanAtomInformationContent& maic);
    
    virtual ~MeanAtomInformationContent();


    MeanAtomInformationContent& operator = (const MeanAtomInformationContent& maic);
  };

  class BALL_EXPORT AtomInformationContent
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(AtomInformationContent)
 
    

    AtomInformationContent();
    
    AtomInformationContent(const AtomInformationContent& aic);

    virtual ~AtomInformationContent();


    AtomInformationContent& operator = (const AtomInformationContent& aic);
    
    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT NumberOfRotatableSingleBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfRotatableSingleBonds)
 
    

    NumberOfRotatableSingleBonds();

    NumberOfRotatableSingleBonds(const NumberOfRotatableSingleBonds& nrsb);

    virtual ~NumberOfRotatableSingleBonds();


    NumberOfRotatableSingleBonds& operator = (const NumberOfRotatableSingleBonds& nrsb);
  };

  class BALL_EXPORT RelNumberOfRotatableSingleBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(RelNumberOfRotatableSingleBonds)
 
    

    RelNumberOfRotatableSingleBonds();

    RelNumberOfRotatableSingleBonds(const RelNumberOfRotatableSingleBonds& rnrsb);

    virtual ~RelNumberOfRotatableSingleBonds();


    RelNumberOfRotatableSingleBonds& operator = (const RelNumberOfRotatableSingleBonds& rnrsb);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT NumberOfAromaticAtoms
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfAromaticAtoms)
 
    

    NumberOfAromaticAtoms();

    NumberOfAromaticAtoms(const NumberOfAromaticAtoms& naa);

    virtual ~NumberOfAromaticAtoms();


    NumberOfAromaticAtoms& operator = (const NumberOfAromaticAtoms& naa);
  };

  class BALL_EXPORT NumberOfHeavyBonds
    : public SimpleBase
  {
    public: 
 
    BALL_CREATE(NumberOfHeavyBonds)
 
    

    NumberOfHeavyBonds();

    NumberOfHeavyBonds(const NumberOfHeavyBonds& nhb);

    virtual ~NumberOfHeavyBonds();


    NumberOfHeavyBonds& operator = (const NumberOfHeavyBonds& nhb);
  };
  
  class BALL_EXPORT NumberOfRotatableBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfRotatableBonds)
 
    

    NumberOfRotatableBonds();

    NumberOfRotatableBonds(const NumberOfRotatableBonds& nrb);
    
    virtual ~NumberOfRotatableBonds();


    NumberOfRotatableBonds& operator = (const NumberOfRotatableBonds& nrb);
  };

  class BALL_EXPORT RelNumberOfRotatableBonds
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(RelNumberOfRotatableBonds)
 
    

    RelNumberOfRotatableBonds();

    RelNumberOfRotatableBonds(const RelNumberOfRotatableBonds& rnrb);

    virtual ~RelNumberOfRotatableBonds();


    RelNumberOfRotatableBonds& operator = (const RelNumberOfRotatableBonds& rnrb);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT VertexAdjacency
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(VertexAdjacency)
 
    

    VertexAdjacency();

    VertexAdjacency(const VertexAdjacency& va);

    virtual ~VertexAdjacency();
    

    VertexAdjacency& operator = (const VertexAdjacency& va);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT VertexAdjacencyEquality
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(VertexAdjacencyEquality)
 
    

    VertexAdjacencyEquality();

    VertexAdjacencyEquality(const VertexAdjacencyEquality& vae);

    virtual ~VertexAdjacencyEquality();


    VertexAdjacencyEquality& operator = (const VertexAdjacencyEquality& vae);

    double compute(AtomContainer& ac);
  };

  class BALL_EXPORT NumberOfHydrogenBondAcceptors
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfHydrogenBondAcceptors)
 
    

    NumberOfHydrogenBondAcceptors();

    NumberOfHydrogenBondAcceptors(const NumberOfHydrogenBondAcceptors& nhba);

    NumberOfHydrogenBondAcceptors(const String& expression);

    virtual ~NumberOfHydrogenBondAcceptors();

    /*_ Getter which returns the Expression string
    */
    const String& getExpression() const;
    
    /*_ Setter which sets the Expression string
    */
    void setExpression(const String& expression);
 
    /*_ This method return the number, which is calculated
        using the Expression string.
    */
    double compute(AtomContainer& ac);
 


    NumberOfHydrogenBondAcceptors& operator = (const NumberOfHydrogenBondAcceptors& nhba);
 
 
    private:
    
    /*_ String which holds the expression.
    */
    String expression_;
  };

  class BALL_EXPORT NumberOfHydrogenBondDonors
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfHydrogenBondDonors)
 
    

    NumberOfHydrogenBondDonors();

    NumberOfHydrogenBondDonors(const NumberOfHydrogenBondDonors& nhbd);

    NumberOfHydrogenBondDonors(const String& expression);

    virtual ~NumberOfHydrogenBondDonors();

    /*_ Setter which sets the Expression string
    */
    void setExpression(const String& expression);
 
    /*_ Getter which returns the Expression string
    */
    const String& getExpression() const;
 
    /*_ Methods which returns the number calcualted from 
        the Expression string.
    */
    double compute(AtomContainer& ac);


    NumberOfHydrogenBondDonors& operator = (const NumberOfHydrogenBondDonors& nhbd);
 
 
    private:
 
    /*_ String which holds the expression.
    */
    String expression_;
  };
  
  class BALL_EXPORT NumberOfHydrophobicAtoms
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(NumberOfHydrophobicAtoms)
 
    

    NumberOfHydrophobicAtoms();

    NumberOfHydrophobicAtoms(const NumberOfHydrophobicAtoms& nha);

    NumberOfHydrophobicAtoms(const String& expression);

    virtual ~NumberOfHydrophobicAtoms();

    /*_ Getter which returns the Expression string
    */
    const String& getExpression() const;
 
    /*_ Setter which set the Expression string
    */
    void setExpression(const String& expression);
 
    /*_ Method which computes the number from the 
        Expression string 
    */
    double compute(AtomContainer& ac);


    NumberOfHydrophobicAtoms& operator = (const NumberOfHydrophobicAtoms& nha);
 
 
    private:
    
    /*_ String which holds the expression
    */
    String expression_;
  };

  class BALL_EXPORT BondPolarizabilities
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(BondPolarizabilities)
 
    

    BondPolarizabilities();

    BondPolarizabilities(const BondPolarizabilities& bp);

    virtual ~BondPolarizabilities();


    BondPolarizabilities& operator = (const BondPolarizabilities& bp);
  };

  class BALL_EXPORT AtomicPolarizabilities
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(AtomicPolarizabilities)
 
    

    AtomicPolarizabilities();

    AtomicPolarizabilities(const AtomicPolarizabilities& ap);

    virtual ~AtomicPolarizabilities();


    AtomicPolarizabilities& operator = (const AtomicPolarizabilities& ap);
  };

  class BALL_EXPORT SizeOfSSSR
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(SizeOfSSSR)
 
    

    SizeOfSSSR();

    SizeOfSSSR(const SizeOfSSSR& sizeofsssr);

    virtual ~SizeOfSSSR();


    SizeOfSSSR& operator = (const SizeOfSSSR& sssr);
  };

  class BALL_EXPORT PrincipalMomentOfInertia
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(PrincipalMomentOfInertia)
 
    

    PrincipalMomentOfInertia();

    PrincipalMomentOfInertia(const PrincipalMomentOfInertia& pmi);

    virtual ~PrincipalMomentOfInertia();


    PrincipalMomentOfInertia& operator = (const PrincipalMomentOfInertia& pmi);
  };

  class BALL_EXPORT PrincipalMomentOfInertiaX
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(PrincipalMomentOfInertiaX)
 
    

    PrincipalMomentOfInertiaX();

    PrincipalMomentOfInertiaX(const PrincipalMomentOfInertiaX& pmix);

    virtual ~PrincipalMomentOfInertiaX();


    PrincipalMomentOfInertiaX& operator = (const PrincipalMomentOfInertiaX& pmix);
  };

  class BALL_EXPORT PrincipalMomentOfInertiaY
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(PrincipalMomentOfInertiaY)
 
    

    PrincipalMomentOfInertiaY();

    PrincipalMomentOfInertiaY(const PrincipalMomentOfInertiaY& pmiy);

    virtual ~PrincipalMomentOfInertiaY();


    PrincipalMomentOfInertiaY& operator = (const PrincipalMomentOfInertiaY& pmiy);
  };

  class BALL_EXPORT PrincipalMomentOfInertiaZ
    : public SimpleBase
  {
    public:
 
    BALL_CREATE(PrincipalMomentOfInertiaZ)
 
    

    PrincipalMomentOfInertiaZ();

    PrincipalMomentOfInertiaZ(const PrincipalMomentOfInertiaZ& pmiz);

    virtual ~PrincipalMomentOfInertiaZ();
    

    PrincipalMomentOfInertiaZ& operator = (const PrincipalMomentOfInertiaZ& pmiz);
  };
 
} // namespace BALL
 
#endif // BALL_QSAR_SIMPLEDESCRIPTORS_H