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