Package schrodinger :: Package infra :: Module _phase

Module _phase

Functions

PhpAlignCore_getAlignedB(...)
PhpAlignCore_getAlignedB(PhpAlignCore self) -> SwigIntVector

PhpAlignCore_getMappings(...)
PhpAlignCore_getMappings(PhpAlignCore self) -> std::vector< PhpCoreMapping,std::allocator< PhpCoreMapping > >

PhpAlignCore_getNumMappings(...)
PhpAlignCore_getNumMappings(PhpAlignCore self) -> size_t

PhpAlignCore_stereoFailure(...)
PhpAlignCore_stereoFailure(PhpAlignCore self) -> bool

PhpAlignCore_swiginit(...)

PhpAlignCore_swigregister(...)

PhpAtomClassDescriptions_getAtomClassDescription(...)
PhpAtomClassDescriptions_getAtomClassDescription(PhpAtomClassDescriptions self, std::string const & atomClass) -> std::string

PhpAtomClassDescriptions_swiginit(...)

PhpAtomClassDescriptions_swigregister(...)

PhpComplex_create(...)
PhpComplex_create(PhpComplex self, MM_Index ligandCt, MM_Index receptorCt, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, std::string const & hypoID, double level=0.5, bool proj=False, bool HR=False, bool RH=False, bool RRdisp=False, bool xvol=False, bool rhypo=False, bool single=False) -> std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > >

PhpComplex_getErrMesg(...)
PhpComplex_getErrMesg(PhpComplex self) -> std::string

PhpComplex_getLimits(...)
PhpComplex_getLimits(PhpComplex self, std::string const & parName) -> SwigDoubleVector

PhpComplex_setDefaultLimits(...)
PhpComplex_setDefaultLimits(PhpComplex self)

PhpComplex_setLimits(...)
PhpComplex_setLimits(PhpComplex self, std::string const & parName, double parStrict, double parRelaxed)

PhpComplex_swiginit(...)

PhpComplex_swigregister(...)

PhpDatabaseFp_distEuclidean(...)
PhpDatabaseFp_distEuclidean(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_distHamming(...)
PhpDatabaseFp_distHamming(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_distSoergel(...)
PhpDatabaseFp_distSoergel(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_getAllIDs(...)
PhpDatabaseFp_getAllIDs(PhpDatabaseFp self) -> SwigSizetVector

PhpDatabaseFp_getCommonCount(...)
PhpDatabaseFp_getCommonCount(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> size_t

PhpDatabaseFp_getCt(...)
PhpDatabaseFp_getCt(PhpDatabaseFp self, size_t molID) -> MM_Index

PhpDatabaseFp_getCts(...)
PhpDatabaseFp_getCts(PhpDatabaseFp self, SwigSizetVector molIDs) -> SwigIntVector

PhpDatabaseFp_getFp(...)
PhpDatabaseFp_getFp(PhpDatabaseFp self, PhpFpType fpType, size_t molID, bool allowMissing=True) -> SwigUnsignedIntVector

PhpDatabaseFp_getFpTypesStored(...)
PhpDatabaseFp_getFpTypesStored(PhpDatabaseFp self) -> SwigPhpFpTypeVector

PhpDatabaseFp_getFps(...)
PhpDatabaseFp_getFps(PhpDatabaseFp self, PhpFpType fpType, SwigSizetVector molIDs, bool allowMissing=True) -> std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >

PhpDatabaseFp_isStored(...)
PhpDatabaseFp_isStored(PhpDatabaseFp self, PhpFpType fpType) -> bool

PhpDatabaseFp_packFp(...)
PhpDatabaseFp_packFp(SwigUnsignedIntVector onBits, size_t molID=0) -> PhpPackedFp

PhpDatabaseFp_simCosine(...)
PhpDatabaseFp_simCosine(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_simDice(...)
PhpDatabaseFp_simDice(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_simTanimoto(...)
PhpDatabaseFp_simTanimoto(SwigUnsignedIntVector fp1, SwigUnsignedIntVector fp2) -> double

PhpDatabaseFp_swiginit(...)

PhpDatabaseFp_swigregister(...)

PhpDatabaseFp_unpackFp(...)
PhpDatabaseFp_unpackFp(PhpPackedFp packedFp) -> SwigUnsignedIntVector

PhpDeNovoPharm_getCentroid(...)
PhpDeNovoPharm_getCentroid(PhpDeNovoPharm self) -> SwigDoubleVector

PhpDeNovoPharm_getCentroidHypo(...)
PhpDeNovoPharm_getCentroidHypo(PhpDeNovoPharm self, std::string const & hypoID) -> PhpHypoAdaptor

PhpDeNovoPharm_getLigandHypo(...)
PhpDeNovoPharm_getLigandHypo(PhpDeNovoPharm self, std::string const & hypoID) -> PhpHypoAdaptor

PhpDeNovoPharm_getReceptorHypo(...)
PhpDeNovoPharm_getReceptorHypo(PhpDeNovoPharm self, std::string const & hypoID) -> PhpHypoAdaptor

PhpDeNovoPharm_getSiteCount(...)
PhpDeNovoPharm_getSiteCount(PhpDeNovoPharm self) -> int

PhpDeNovoPharm_getSitePairs(...)
PhpDeNovoPharm_getSitePairs(PhpDeNovoPharm self) -> SwigVectorPhpSitePhpSite

PhpDeNovoPharm_swiginit(...)

PhpDeNovoPharm_swigregister(...)

PhpDeltaHypoSite_deltaXYZ_get(...)
PhpDeltaHypoSite_deltaXYZ_get(PhpDeltaHypoSite self) -> double

PhpDeltaHypoSite_deltaXYZ_set(...)
PhpDeltaHypoSite_deltaXYZ_set(PhpDeltaHypoSite self, double deltaXYZ)

PhpDeltaHypoSite_siteNumber_get(...)
PhpDeltaHypoSite_siteNumber_get(PhpDeltaHypoSite self) -> size_t

PhpDeltaHypoSite_siteNumber_set(...)
PhpDeltaHypoSite_siteNumber_set(PhpDeltaHypoSite self, size_t siteNumber)

PhpDeltaHypoSite_siteType_get(...)
PhpDeltaHypoSite_siteType_get(PhpDeltaHypoSite self) -> char

PhpDeltaHypoSite_siteType_set(...)
PhpDeltaHypoSite_siteType_set(PhpDeltaHypoSite self, char siteType)

PhpDeltaHypoSite_swiginit(...)

PhpDeltaHypoSite_swigregister(...)

PhpDeltaHypo_addSiteData(...)
addSiteData(char siteType, double deltaXYZ) addSiteData(size_t siteNumber, char siteType, double deltaXYZ) PhpDeltaHypo_addSiteData(PhpDeltaHypo self, PhpDeltaHypoSite siteData)

PhpDeltaHypo_clear(...)
PhpDeltaHypo_clear(PhpDeltaHypo self)

PhpDeltaHypo_exportToFile(...)
PhpDeltaHypo_exportToFile(PhpDeltaHypo self, std::string const & fileName)

PhpDeltaHypo_exportToStream(...)
PhpDeltaHypo_exportToStream(PhpDeltaHypo self, std::ostream & outStream)

PhpDeltaHypo_getDeltaXYZ(...)
PhpDeltaHypo_getDeltaXYZ(PhpDeltaHypo self, size_t siteIndex) -> double

PhpDeltaHypo_getSiteData(...)
PhpDeltaHypo_getSiteData(PhpDeltaHypo self, size_t siteIndex) -> PhpDeltaHypoSite

PhpDeltaHypo_getSiteNumber(...)
PhpDeltaHypo_getSiteNumber(PhpDeltaHypo self, size_t siteIndex) -> size_t

PhpDeltaHypo_getSiteType(...)
PhpDeltaHypo_getSiteType(PhpDeltaHypo self, size_t siteIndex) -> char

PhpDeltaHypo_importFromFile(...)
PhpDeltaHypo_importFromFile(PhpDeltaHypo self, std::string const & fileName)

PhpDeltaHypo_importFromStream(...)
PhpDeltaHypo_importFromStream(PhpDeltaHypo self, std::istream & inStream)

PhpDeltaHypo_numSites(...)
PhpDeltaHypo_numSites(PhpDeltaHypo self) -> size_t

PhpDeltaHypo_swiginit(...)

PhpDeltaHypo_swigregister(...)

PhpException_errCode_get(...)
PhpException_errCode_get(PhpException self) -> int

PhpException_errCode_set(...)
PhpException_errCode_set(PhpException self, int errCode)

PhpException_errMesg_get(...)
PhpException_errMesg_get(PhpException self) -> std::string const &

PhpException_errMesg_set(...)
PhpException_errMesg_set(PhpException self, std::string const & errMesg)

PhpException_swiginit(...)

PhpException_swigregister(...)

PhpException_what(...)
PhpException_what(PhpException self) -> char const *

PhpExclVolSphere_r_get(...)
PhpExclVolSphere_r_get(PhpExclVolSphere self) -> double

PhpExclVolSphere_r_set(...)
PhpExclVolSphere_r_set(PhpExclVolSphere self, double r)

PhpExclVolSphere_swiginit(...)

PhpExclVolSphere_swigregister(...)

PhpExclVolSphere_x_get(...)
PhpExclVolSphere_x_get(PhpExclVolSphere self) -> double

PhpExclVolSphere_x_set(...)
PhpExclVolSphere_x_set(PhpExclVolSphere self, double x)

PhpExclVolSphere_y_get(...)
PhpExclVolSphere_y_get(PhpExclVolSphere self) -> double

PhpExclVolSphere_y_set(...)
PhpExclVolSphere_y_set(PhpExclVolSphere self, double y)

PhpExclVolSphere_z_get(...)
PhpExclVolSphere_z_get(PhpExclVolSphere self) -> double

PhpExclVolSphere_z_set(...)
PhpExclVolSphere_z_set(PhpExclVolSphere self, double z)

PhpExclVol_addSphere(...)
addSphere(double x, double y, double z, double r) PhpExclVol_addSphere(PhpExclVol self, PhpExclVolSphere sphere)

PhpExclVol_append(...)
PhpExclVol_append(PhpExclVol self, PhpExclVol xvol)

PhpExclVol_clear(...)
PhpExclVol_clear(PhpExclVol self)

PhpExclVol_exportToFile(...)
PhpExclVol_exportToFile(PhpExclVol self, std::string const & fileName)

PhpExclVol_exportToMMTableFile(...)
PhpExclVol_exportToMMTableFile(PhpExclVol self, std::string const & fileName)

PhpExclVol_exportToStream(...)
PhpExclVol_exportToStream(PhpExclVol self, std::ostream & outStream)

PhpExclVol_filter(...)
PhpExclVol_filter(PhpExclVol self, MM_Index ct, bool treatHydrogens) -> PhpExclVol

PhpExclVol_findViolations(...)
PhpExclVol_findViolations(PhpExclVol self, MM_Index ctHandle, size_t maxViolations) -> SwigSizetVector

PhpExclVol_getSphere(...)
PhpExclVol_getSphere(PhpExclVol self, size_t sphereIndex) -> PhpExclVolSphere

PhpExclVol_getSphereRadius(...)
PhpExclVol_getSphereRadius(PhpExclVol self, size_t sphereIndex) -> double

PhpExclVol_getSphereXYZ(...)
PhpExclVol_getSphereXYZ(PhpExclVol self, size_t sphereIndex)

PhpExclVol_getSpheres(...)
PhpExclVol_getSpheres(PhpExclVol self) -> std::vector< PhpExclVolSphere,std::allocator< PhpExclVolSphere > >

PhpExclVol_getTreatHydrogens(...)
PhpExclVol_getTreatHydrogens(PhpExclVol self) -> bool

PhpExclVol_importFromAnyFile(...)
PhpExclVol_importFromAnyFile(PhpExclVol self, std::string const & fileName)

PhpExclVol_importFromFile(...)
PhpExclVol_importFromFile(PhpExclVol self, std::string const & fileName)

PhpExclVol_importFromMMTableFile(...)
PhpExclVol_importFromMMTableFile(PhpExclVol self, std::string const & fileName)

PhpExclVol_importFromStream(...)
PhpExclVol_importFromStream(PhpExclVol self, std::istream & inStream)

PhpExclVol_numShapes(...)
PhpExclVol_numShapes(PhpExclVol self) -> size_t

PhpExclVol_numSpheres(...)
PhpExclVol_numSpheres(PhpExclVol self) -> size_t

PhpExclVol_removeSphere(...)
PhpExclVol_removeSphere(PhpExclVol self, size_t sphereIndex)

PhpExclVol_setSphereRadius(...)
PhpExclVol_setSphereRadius(PhpExclVol self, size_t sphereIndex, double r)

PhpExclVol_setSphereXYZ(...)
PhpExclVol_setSphereXYZ(PhpExclVol self, size_t sphereIndex, double x, double y, double z)

PhpExclVol_setTreatHydrogens(...)
PhpExclVol_setTreatHydrogens(PhpExclVol self, bool treatHydrogens)

PhpExclVol_swiginit(...)

PhpExclVol_swigregister(...)

PhpFastShapePair_a_get(...)
PhpFastShapePair_a_get(PhpFastShapePair self) -> double

PhpFastShapePair_a_set(...)
PhpFastShapePair_a_set(PhpFastShapePair self, double a)

PhpFastShapePair_b_get(...)
PhpFastShapePair_b_get(PhpFastShapePair self) -> double

PhpFastShapePair_b_set(...)
PhpFastShapePair_b_set(PhpFastShapePair self, double b)

PhpFastShapePair_c_get(...)
PhpFastShapePair_c_get(PhpFastShapePair self) -> double

PhpFastShapePair_c_set(...)
PhpFastShapePair_c_set(PhpFastShapePair self, double c)

PhpFastShapePair_i1_get(...)
PhpFastShapePair_i1_get(PhpFastShapePair self) -> size_t

PhpFastShapePair_i1_set(...)
PhpFastShapePair_i1_set(PhpFastShapePair self, size_t i1)

PhpFastShapePair_i2_get(...)
PhpFastShapePair_i2_get(PhpFastShapePair self) -> size_t

PhpFastShapePair_i2_set(...)
PhpFastShapePair_i2_set(PhpFastShapePair self, size_t i2)

PhpFastShapePair_swiginit(...)

PhpFastShapePair_swigregister(...)

PhpFastShape_alignCt(...)
PhpFastShape_alignCt(PhpFastShape self, MM_Index ctHandle, double const [3] trans, double const [3][3] rot)

PhpFastShape_alignCtPy(...)
PhpFastShape_alignCtPy(PhpFastShape self, MM_Index ctHandle, SwigDoubleVector simTrans)

PhpFastShape_computeShapeSim(...)
computeShapeSim(SwigVectorDoubleVector xyz, SwigDoubleVector r, bool first, bool inplace, double & sim, double [3] trans, double [3][3] rot) computeShapeSim(SwigVectorDoubleVector xyz, SwigDoubleVector r, SwigIntVector stype, bool first, bool inplace, double & sim, double [3] trans, double [3][3] rot) computeShapeSim(MM_Index ctHandle, bool first, bool inplace, double & sim, double [3] trans, double [3][3] rot) PhpFastShape_computeShapeSim(PhpFastShape self, std::vector< PhpSite,std::allocator< PhpSite > > const & sites, PhpLcsMap const & lcsMap, bool first, bool inplace, double & sim, double [3] trans, double [3][3] rot)

PhpFastShape_computeShapeSimPy(...)
PhpFastShape_computeShapeSimPy(PhpFastShape self, MM_Index ctHandle, bool first, bool inplace) -> SwigDoubleVector

PhpFastShape_setDebug(...)
PhpFastShape_setDebug(PhpFastShape self, bool debug)

PhpFastShape_swiginit(...)

PhpFastShape_swigregister(...)

PhpFeatureClassDescriptions_getFeatureClassDescription(...)
PhpFeatureClassDescriptions_getFeatureClassDescription(PhpFeatureClassDescriptions self, std::string const & featureClass) -> std::string

PhpFeatureClassDescriptions_swiginit(...)

PhpFeatureClassDescriptions_swigregister(...)

PhpFeatureData_clear(...)
PhpFeatureData_clear(PhpFeatureData self)

PhpFeatureData_exportToFile(...)
PhpFeatureData_exportToFile(PhpFeatureData self, char const * fileName)

PhpFeatureData_exportToStream(...)
PhpFeatureData_exportToStream(PhpFeatureData self, std::ostream & outStream)

PhpFeatureData_getDataColumn(...)
PhpFeatureData_getDataColumn(PhpFeatureData self, std::string const & variant, size_t dataColumn=0) -> SwigDoubleVector

PhpFeatureData_getDataRow(...)
PhpFeatureData_getDataRow(PhpFeatureData self, char featureType) -> SwigDoubleVector

PhpFeatureData_getDataValue(...)
PhpFeatureData_getDataValue(PhpFeatureData self, char featureType) -> double

PhpFeatureData_importFromFile(...)
PhpFeatureData_importFromFile(PhpFeatureData self, char const * fileName)

PhpFeatureData_importFromStream(...)
PhpFeatureData_importFromStream(PhpFeatureData self, std::istream & inStream)

PhpFeatureData_numDataColumns(...)
PhpFeatureData_numDataColumns(PhpFeatureData self) -> size_t

PhpFeatureData_setDataRow(...)
PhpFeatureData_setDataRow(PhpFeatureData self, char featureType, SwigDoubleVector dataRow)

PhpFeatureData_setDataValue(...)
PhpFeatureData_setDataValue(PhpFeatureData self, char featureType, double dataValue)

PhpFeatureData_setDefaultDataRow(...)
PhpFeatureData_setDefaultDataRow(PhpFeatureData self, SwigDoubleVector dataRow)

PhpFeatureData_setDefaultDataValue(...)
PhpFeatureData_setDefaultDataValue(PhpFeatureData self, double dataValue)

PhpFeatureData_swiginit(...)

PhpFeatureData_swigregister(...)

PhpFeatureDefinition___eq__(...)
PhpFeatureDefinition___eq__(PhpFeatureDefinition self, PhpFeatureDefinition arg3) -> bool

PhpFeatureDefinition___ne__(...)
PhpFeatureDefinition___ne__(PhpFeatureDefinition self, PhpFeatureDefinition rhs) -> bool

PhpFeatureDefinition_addStaticFragmentPatterns(...)
PhpFeatureDefinition_addStaticFragmentPatterns(PhpFeatureDefinition self)

PhpFeatureDefinition_clear(...)
PhpFeatureDefinition_clear(PhpFeatureDefinition self)

PhpFeatureDefinition_getAllExcludes(...)
PhpFeatureDefinition_getAllExcludes(PhpFeatureDefinition self) -> std::vector< PhpFeaturePattern,std::allocator< PhpFeaturePattern > >

PhpFeatureDefinition_getAllIncludes(...)
PhpFeatureDefinition_getAllIncludes(PhpFeatureDefinition self) -> std::vector< PhpFeaturePattern,std::allocator< PhpFeaturePattern > >

PhpFeatureDefinition_getExcludePattern(...)
PhpFeatureDefinition_getExcludePattern(PhpFeatureDefinition self, size_t a_i) -> PhpFeaturePattern

PhpFeatureDefinition_getExtendDistance(...)
PhpFeatureDefinition_getExtendDistance(PhpFeatureDefinition self) -> double

PhpFeatureDefinition_getFeatureComment(...)
PhpFeatureDefinition_getFeatureComment(PhpFeatureDefinition self) -> std::string

PhpFeatureDefinition_getFeatureName(...)
PhpFeatureDefinition_getFeatureName(PhpFeatureDefinition self) -> std::string

PhpFeatureDefinition_getFeatureNumber(...)
PhpFeatureDefinition_getFeatureNumber(PhpFeatureDefinition self) -> size_t

PhpFeatureDefinition_getFeatureType(...)
PhpFeatureDefinition_getFeatureType(PhpFeatureDefinition self) -> char

PhpFeatureDefinition_getIncludePattern(...)
PhpFeatureDefinition_getIncludePattern(PhpFeatureDefinition self, size_t a_i) -> PhpFeaturePattern

PhpFeatureDefinition_getNumExcludes(...)
PhpFeatureDefinition_getNumExcludes(PhpFeatureDefinition self) -> size_t

PhpFeatureDefinition_getNumIncludes(...)
PhpFeatureDefinition_getNumIncludes(PhpFeatureDefinition self) -> size_t

PhpFeatureDefinition_getProjectedType(...)
PhpFeatureDefinition_getProjectedType(PhpFeatureDefinition self) -> bool

PhpFeatureDefinition_getSasOptions(...)
PhpFeatureDefinition_getSasOptions(PhpFeatureDefinition self) -> PhpSASOptions

PhpFeatureDefinition_setAllExcludes(...)
PhpFeatureDefinition_setAllExcludes(PhpFeatureDefinition self, std::vector< PhpFeaturePattern,std::allocator< PhpFeaturePattern > > & rhs)

PhpFeatureDefinition_setAllIncludes(...)
PhpFeatureDefinition_setAllIncludes(PhpFeatureDefinition self, std::vector< PhpFeaturePattern,std::allocator< PhpFeaturePattern > > & rhs)

PhpFeatureDefinition_setExcludePattern(...)
PhpFeatureDefinition_setExcludePattern(PhpFeatureDefinition self, PhpFeaturePattern rhs)

PhpFeatureDefinition_setExtendDistance(...)
PhpFeatureDefinition_setExtendDistance(PhpFeatureDefinition self, double const a_d)

PhpFeatureDefinition_setFeatureComment(...)
PhpFeatureDefinition_setFeatureComment(PhpFeatureDefinition self, std::string const a_comment)

PhpFeatureDefinition_setFeatureName(...)
PhpFeatureDefinition_setFeatureName(PhpFeatureDefinition self, std::string const & a_name)

PhpFeatureDefinition_setFeatureNumber(...)
PhpFeatureDefinition_setFeatureNumber(PhpFeatureDefinition self, size_t a_i)

PhpFeatureDefinition_setFeatureType(...)
PhpFeatureDefinition_setFeatureType(PhpFeatureDefinition self, char a_type)

PhpFeatureDefinition_setIncludePattern(...)
PhpFeatureDefinition_setIncludePattern(PhpFeatureDefinition self, PhpFeaturePattern rhs)

PhpFeatureDefinition_setProjectedTypeOff(...)
PhpFeatureDefinition_setProjectedTypeOff(PhpFeatureDefinition self)

PhpFeatureDefinition_setProjectedTypeOn(...)
PhpFeatureDefinition_setProjectedTypeOn(PhpFeatureDefinition self)

PhpFeatureDefinition_setSasOptions(...)
PhpFeatureDefinition_setSasOptions(PhpFeatureDefinition self, PhpSASOptions const & a_sas)

PhpFeatureDefinition_swiginit(...)

PhpFeatureDefinition_swigregister(...)

PhpFeatureFinder_execute(...)
PhpFeatureFinder_execute(PhpFeatureFinder self)

PhpFeatureFinder_getAllFeatures(...)
PhpFeatureFinder_getAllFeatures(PhpFeatureFinder self) -> std::vector< PhpBaseFeature,std::allocator< PhpBaseFeature > >

PhpFeatureFinder_setCTSource(...)
PhpFeatureFinder_setCTSource(PhpFeatureFinder self, int a_ct)

PhpFeatureFinder_setFeatureDefinitions(...)
PhpFeatureFinder_setFeatureDefinitions(PhpFeatureFinder self, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & a_fd)

PhpFeatureFinder_swiginit(...)

PhpFeatureFinder_swigregister(...)

PhpFeaturePattern___eq__(...)
PhpFeaturePattern___eq__(PhpFeaturePattern self, PhpFeaturePattern arg3) -> bool

PhpFeaturePattern___ne__(...)
PhpFeaturePattern___ne__(PhpFeaturePattern self, PhpFeaturePattern rhs) -> bool

PhpFeaturePattern_getAtomList(...)
PhpFeaturePattern_getAtomList(PhpFeaturePattern self) -> SwigSizetVector

PhpFeaturePattern_getEditStatus(...)
PhpFeaturePattern_getEditStatus(PhpFeaturePattern self) -> bool

PhpFeaturePattern_getExtendDistance(...)
PhpFeaturePattern_getExtendDistance(PhpFeaturePattern self) -> double

PhpFeaturePattern_getGeometry(...)
PhpFeaturePattern_getGeometry(PhpFeaturePattern self) -> std::string

PhpFeaturePattern_getPattern(...)
PhpFeaturePattern_getPattern(PhpFeaturePattern self) -> std::string

PhpFeaturePattern_getPatternID(...)
PhpFeaturePattern_getPatternID(PhpFeaturePattern self) -> int

PhpFeaturePattern_getPattyHandle(...)
PhpFeaturePattern_getPattyHandle(PhpFeaturePattern self) -> int

PhpFeaturePattern_getProjectedType(...)
PhpFeaturePattern_getProjectedType(PhpFeaturePattern self) -> int

PhpFeaturePattern_getSummary(...)
PhpFeaturePattern_getSummary(PhpFeaturePattern self) -> std::string

PhpFeaturePattern_getType(...)
PhpFeaturePattern_getType(PhpFeaturePattern self) -> int

PhpFeaturePattern_getTypeSimilarity(...)
PhpFeaturePattern_getTypeSimilarity(PhpFeaturePattern self) -> int

PhpFeaturePattern_getUsedStatus(...)
PhpFeaturePattern_getUsedStatus(PhpFeaturePattern self) -> bool

PhpFeaturePattern_setAtomList(...)
PhpFeaturePattern_setAtomList(PhpFeaturePattern self, SwigSizetVector rhs)

PhpFeaturePattern_setEditOff(...)
PhpFeaturePattern_setEditOff(PhpFeaturePattern self)

PhpFeaturePattern_setEditOn(...)
PhpFeaturePattern_setEditOn(PhpFeaturePattern self)

PhpFeaturePattern_setExtendDistance(...)
PhpFeaturePattern_setExtendDistance(PhpFeaturePattern self, double const a_d)

PhpFeaturePattern_setGeometry(...)
PhpFeaturePattern_setGeometry(PhpFeaturePattern self, std::string const & a_geometry)

PhpFeaturePattern_setPattern(...)
PhpFeaturePattern_setPattern(PhpFeaturePattern self, std::string const & a_pattern)

PhpFeaturePattern_setPatternID(...)
PhpFeaturePattern_setPatternID(PhpFeaturePattern self, int a_patternID)

PhpFeaturePattern_setPattyHandle(...)
PhpFeaturePattern_setPattyHandle(PhpFeaturePattern self, int const a_handle)

PhpFeaturePattern_setProjectedType(...)
PhpFeaturePattern_setProjectedType(PhpFeaturePattern self, int a_type)

PhpFeaturePattern_setType(...)
PhpFeaturePattern_setType(PhpFeaturePattern self, int a_type)

PhpFeaturePattern_setTypeSimilarity(...)
PhpFeaturePattern_setTypeSimilarity(PhpFeaturePattern self, int a_typeSimilarity)

PhpFeaturePattern_setUsedOff(...)
PhpFeaturePattern_setUsedOff(PhpFeaturePattern self)

PhpFeaturePattern_setUsedOn(...)
PhpFeaturePattern_setUsedOn(PhpFeaturePattern self)

PhpFeaturePattern_swiginit(...)

PhpFeaturePattern_swigregister(...)

PhpFeatureRules_addRule(...)
PhpFeatureRules_addRule(PhpFeatureRules self, size_t siteNumber, std::string const & permitted, std::string const & prohibited)

PhpFeatureRules_clear(...)
PhpFeatureRules_clear(PhpFeatureRules self)

PhpFeatureRules_containsVariant(...)
PhpFeatureRules_containsVariant(PhpFeatureRules self, std::string const & variant) -> bool

PhpFeatureRules_exportToFile(...)
PhpFeatureRules_exportToFile(PhpFeatureRules self, std::string const & ruleFile)

PhpFeatureRules_exportToStream(...)
PhpFeatureRules_exportToStream(PhpFeatureRules self, std::ostream & ruleStream)

SwigStringVector

PhpFeatureRules_getPermittedFeatures()
PhpFeatureRules_getPermittedFeatures(PhpFeatureRules self, size_t siteIndex) -> std::string

SwigStringVector

PhpFeatureRules_getProhibitedFeatures()
PhpFeatureRules_getProhibitedFeatures(PhpFeatureRules self, size_t siteIndex) -> std::string

PhpFeatureRules_getSiteNumber(...)
PhpFeatureRules_getSiteNumber(PhpFeatureRules self, size_t siteIndex) -> size_t

PhpFeatureRules_getVariant(...)
PhpFeatureRules_getVariant(PhpFeatureRules self) -> std::string

PhpFeatureRules_hasMixedFeatures(...)
PhpFeatureRules_hasMixedFeatures(PhpFeatureRules self) -> bool

PhpFeatureRules_importFromFile(...)
PhpFeatureRules_importFromFile(PhpFeatureRules self, std::string const & ruleFile)

PhpFeatureRules_importFromStream(...)
PhpFeatureRules_importFromStream(PhpFeatureRules self, std::istream & ruleStream)

PhpFeatureRules_numSites(...)
PhpFeatureRules_numSites(PhpFeatureRules self) -> size_t

PhpFeatureRules_swiginit(...)

PhpFeatureRules_swigregister(...)

PhpFragPair_fragType_get(...)
PhpFragPair_fragType_get(PhpFragPair self) -> std::string const &

PhpFragPair_fragType_set(...)
PhpFragPair_fragType_set(PhpFragPair self, std::string const & fragType)

PhpFragPair_projType_get(...)
PhpFragPair_projType_get(PhpFragPair self) -> int

PhpFragPair_projType_set(...)
PhpFragPair_projType_set(PhpFragPair self, int projType)

PhpFragPair_swiginit(...)

PhpFragPair_swigregister(...)

PhpHiClusterPair_cluster1_get(...)
PhpHiClusterPair_cluster1_get(PhpHiClusterPair self) -> SwigSizetVector

PhpHiClusterPair_cluster1_set(...)
PhpHiClusterPair_cluster1_set(PhpHiClusterPair self, SwigSizetVector cluster1)

PhpHiClusterPair_cluster2_get(...)
PhpHiClusterPair_cluster2_get(PhpHiClusterPair self) -> SwigSizetVector

PhpHiClusterPair_cluster2_set(...)
PhpHiClusterPair_cluster2_set(PhpHiClusterPair self, SwigSizetVector cluster2)

PhpHiClusterPair_d12_get(...)
PhpHiClusterPair_d12_get(PhpHiClusterPair self) -> double

PhpHiClusterPair_d12_set(...)
PhpHiClusterPair_d12_set(PhpHiClusterPair self, double d12)

PhpHiClusterPair_swiginit(...)

PhpHiClusterPair_swigregister(...)

PhpHiCluster_clear(...)
PhpHiCluster_clear(PhpHiCluster self)

PhpHiCluster_clearClusters(...)
PhpHiCluster_clearClusters(PhpHiCluster self)

PhpHiCluster_createClusters(...)
PhpHiCluster_createClusters(PhpHiCluster self)

PhpHiCluster_getClusterCutPoints(...)
PhpHiCluster_getClusterCutPoints(PhpHiCluster self, size_t numClusters) -> SwigSizetVector

PhpHiCluster_getClusterSizes(...)
PhpHiCluster_getClusterSizes(PhpHiCluster self, size_t numClusters) -> SwigSizetVector

PhpHiCluster_getClusters(...)
PhpHiCluster_getClusters(PhpHiCluster self, size_t numClusters) -> SwigVectorSizetVector

PhpHiCluster_getClustersMerged(...)
PhpHiCluster_getClustersMerged(PhpHiCluster self, size_t numClusters) -> PhpHiClusterPair

PhpHiCluster_numObs(...)
PhpHiCluster_numObs(PhpHiCluster self) -> size_t

PhpHiCluster_printSummary(...)
PhpHiCluster_printSummary(PhpHiCluster self, std::ostream & outStream, size_t base=0)

PhpHiCluster_setDmatrix(...)
PhpHiCluster_setDmatrix(PhpHiCluster self, SwigVectorDoubleVector dmatrix)

PhpHiCluster_setLinkageType(...)
PhpHiCluster_setLinkageType(PhpHiCluster self, int const linkageType)

PhpHiCluster_swiginit(...)

PhpHiCluster_swigregister(...)

PhpHypoAdaptor_addAttr(...)
PhpHypoAdaptor_addAttr(PhpHypoAdaptor self, std::string const & fileName, bool hydrogens=False)

PhpHypoAdaptor_addCnst(...)
PhpHypoAdaptor_addCnst(PhpHypoAdaptor self, PhpSiteConstrainer cnst)

PhpHypoAdaptor_addCt(...)
PhpHypoAdaptor_addCt(PhpHypoAdaptor self, MM_Index ctHandle, std::string const & role)

PhpHypoAdaptor_addIvol(...)
PhpHypoAdaptor_addIvol(PhpHypoAdaptor self, PhpExclVol ivol)

PhpHypoAdaptor_addMask(...)
PhpHypoAdaptor_addMask(PhpHypoAdaptor self, PhpSiteMask mask)

PhpHypoAdaptor_addProp(...)
addProp(std::string const & propName, std::string const & propValue) addProp(std::string const & propName, int propValue) PhpHypoAdaptor_addProp(PhpHypoAdaptor self, std::string const & propName, double propValue)

PhpHypoAdaptor_addQsar(...)
PhpHypoAdaptor_addQsar(PhpHypoAdaptor self, PhpQSAR qsar)

PhpHypoAdaptor_addRad(...)
PhpHypoAdaptor_addRad(PhpHypoAdaptor self, PhpFeatureData rad)

PhpHypoAdaptor_addRules(...)
PhpHypoAdaptor_addRules(PhpHypoAdaptor self, PhpFeatureRules rules)

PhpHypoAdaptor_addSite(...)
PhpHypoAdaptor_addSite(PhpHypoAdaptor self, PhpSite site)

PhpHypoAdaptor_addTol(...)
PhpHypoAdaptor_addTol(PhpHypoAdaptor self, PhpDeltaHypo tol)

PhpHypoAdaptor_addTolByType(...)
PhpHypoAdaptor_addTolByType(PhpHypoAdaptor self, PhpFeatureData tol)

PhpHypoAdaptor_addXvol(...)
PhpHypoAdaptor_addXvol(PhpHypoAdaptor self, PhpExclVol xvol, bool hydrogens=False)

PhpHypoAdaptor_buildAllAttr(...)
PhpHypoAdaptor_buildAllAttr(PhpHypoAdaptor self, bool mustExist=False)

PhpHypoAdaptor_convert(...)
PhpHypoAdaptor_convert(PhpHypoAdaptor self, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd)

PhpHypoAdaptor_convertToStatic(...)
convertToStatic(std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd) PhpHypoAdaptor_convertToStatic(PhpHypoAdaptor self)

PhpHypoAdaptor_deleteAttr(...)
PhpHypoAdaptor_deleteAttr(PhpHypoAdaptor self, std::string const & name)

PhpHypoAdaptor_deleteSite(...)
PhpHypoAdaptor_deleteSite(PhpHypoAdaptor self, size_t siteIndex)

PhpHypoAdaptor_deleteSiteFast(...)
PhpHypoAdaptor_deleteSiteFast(PhpHypoAdaptor self, size_t siteIndex)

PhpHypoAdaptor_getAddCtCount(...)
PhpHypoAdaptor_getAddCtCount(PhpHypoAdaptor self) -> int

PhpHypoAdaptor_getAddCts(...)
PhpHypoAdaptor_getAddCts(PhpHypoAdaptor self) -> SwigIntVector

PhpHypoAdaptor_getCnst(...)
PhpHypoAdaptor_getCnst(PhpHypoAdaptor self) -> PhpSiteConstrainer

PhpHypoAdaptor_getFd(...)
PhpHypoAdaptor_getFd(PhpHypoAdaptor self) -> std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > >

PhpHypoAdaptor_getHypoCt(...)
PhpHypoAdaptor_getHypoCt(PhpHypoAdaptor self) -> MM_Index

PhpHypoAdaptor_getHypoID(...)
PhpHypoAdaptor_getHypoID(PhpHypoAdaptor self) -> std::string

PhpHypoAdaptor_getHypoSites(...)
PhpHypoAdaptor_getHypoSites(PhpHypoAdaptor self, bool wantProj=False) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpHypoAdaptor_getIvol(...)
PhpHypoAdaptor_getIvol(PhpHypoAdaptor self) -> PhpExclVol

PhpHypoAdaptor_getMask(...)
PhpHypoAdaptor_getMask(PhpHypoAdaptor self) -> PhpSiteMask

PhpHypoAdaptor_getProp(...)
PhpHypoAdaptor_getProp(PhpHypoAdaptor self, std::string const & propName) -> std::string

PhpHypoAdaptor_getQsar(...)
PhpHypoAdaptor_getQsar(PhpHypoAdaptor self) -> PhpQSAR

PhpHypoAdaptor_getRad(...)
PhpHypoAdaptor_getRad(PhpHypoAdaptor self) -> PhpFeatureData

PhpHypoAdaptor_getRefCt(...)
PhpHypoAdaptor_getRefCt(PhpHypoAdaptor self) -> MM_Index

PhpHypoAdaptor_getRefSites(...)
PhpHypoAdaptor_getRefSites(PhpHypoAdaptor self, bool wantProj=False, bool append=False) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpHypoAdaptor_getRules(...)
PhpHypoAdaptor_getRules(PhpHypoAdaptor self) -> PhpFeatureRules

PhpHypoAdaptor_getSite(...)
PhpHypoAdaptor_getSite(PhpHypoAdaptor self, size_t siteIndex) -> PhpSite

PhpHypoAdaptor_getSiteByDisplayName(...)
PhpHypoAdaptor_getSiteByDisplayName(PhpHypoAdaptor self, std::string const & displayName) -> PhpSite

PhpHypoAdaptor_getSiteCount(...)
PhpHypoAdaptor_getSiteCount(PhpHypoAdaptor self) -> int

PhpHypoAdaptor_getSiteIndexFromDisplayName(...)
PhpHypoAdaptor_getSiteIndexFromDisplayName(PhpHypoAdaptor self, std::string const & displayName) -> size_t

PhpHypoAdaptor_getSiteTypes(...)
PhpHypoAdaptor_getSiteTypes(PhpHypoAdaptor self) -> std::string

PhpHypoAdaptor_getSummary(...)
PhpHypoAdaptor_getSummary(PhpHypoAdaptor self, bool extended=False) -> std::string

PhpHypoAdaptor_getTol(...)
PhpHypoAdaptor_getTol(PhpHypoAdaptor self) -> PhpDeltaHypo

PhpHypoAdaptor_getXvol(...)
PhpHypoAdaptor_getXvol(PhpHypoAdaptor self) -> PhpExclVol

PhpHypoAdaptor_hasAddCts(...)
PhpHypoAdaptor_hasAddCts(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasCnst(...)
PhpHypoAdaptor_hasCnst(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasIvol(...)
PhpHypoAdaptor_hasIvol(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasMask(...)
PhpHypoAdaptor_hasMask(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasQsar(...)
PhpHypoAdaptor_hasQsar(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasRad(...)
PhpHypoAdaptor_hasRad(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasRefCt(...)
PhpHypoAdaptor_hasRefCt(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasRules(...)
PhpHypoAdaptor_hasRules(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasTol(...)
PhpHypoAdaptor_hasTol(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_hasXvol(...)
PhpHypoAdaptor_hasXvol(PhpHypoAdaptor self) -> bool

PhpHypoAdaptor_merge(...)
PhpHypoAdaptor_merge(PhpHypoAdaptor self, PhpHypoAdaptor rhs, double tol)

PhpHypoAdaptor_save(...)
PhpHypoAdaptor_save(PhpHypoAdaptor self, std::string const & hypoID, bool overwrite)

PhpHypoAdaptor_setHypoID(...)
PhpHypoAdaptor_setHypoID(PhpHypoAdaptor self, std::string const & hypoID)

PhpHypoAdaptor_setRefCtTitle(...)
PhpHypoAdaptor_setRefCtTitle(PhpHypoAdaptor self, std::string const & title)

PhpHypoAdaptor_swiginit(...)

PhpHypoAdaptor_swigregister(...)

PhpHypoAdaptor_updateSite(...)
PhpHypoAdaptor_updateSite(PhpHypoAdaptor self, size_t siteIndex, PhpSite site)

PhpHypoAdaptor_writeSummary(...)
PhpHypoAdaptor_writeSummary(PhpHypoAdaptor self, std::ostream & os, bool extended=False)

PhpIntCoord_atoms_get(...)
PhpIntCoord_atoms_get(PhpIntCoord self) -> SwigSizetVector

PhpIntCoord_atoms_set(...)
PhpIntCoord_atoms_set(PhpIntCoord self, SwigSizetVector atoms)

PhpIntCoord_coords_get(...)
PhpIntCoord_coords_get(PhpIntCoord self) -> SwigDoubleVector

PhpIntCoord_coords_set(...)
PhpIntCoord_coords_set(PhpIntCoord self, SwigDoubleVector coords)

PhpIntCoord_swiginit(...)

PhpIntCoord_swigregister(...)

PhpPackedFp_bits_get(...)
PhpPackedFp_bits_get(PhpPackedFp self) -> std::string const &

PhpPackedFp_bits_set(...)
PhpPackedFp_bits_set(PhpPackedFp self, std::string const & bits)

PhpPackedFp_lenOrig_get(...)
PhpPackedFp_lenOrig_get(PhpPackedFp self) -> size_t

PhpPackedFp_lenOrig_set(...)
PhpPackedFp_lenOrig_set(PhpPackedFp self, size_t lenOrig)

PhpPackedFp_molID_get(...)
PhpPackedFp_molID_get(PhpPackedFp self) -> size_t

PhpPackedFp_molID_set(...)
PhpPackedFp_molID_set(PhpPackedFp self, size_t molID)

PhpPackedFp_swiginit(...)

PhpPackedFp_swigregister(...)

PhpProject_addLigands(...)
addLigands(std::string const & projectName, std::string const & inFile, bool connect, bool stereo, std::string const & titleProp, std::string const & actProp, std::string const & jobName, bool save) PhpProject_addLigands(PhpProject self, std::string const & projectName, std::string const & sourceProjectName, SwigIntVector ligandIDs, std::string const & actProp, std::string const & jobName, bool save)

PhpProject_afterStep(...)
PhpProject_afterStep(PhpProject self, std::string const & proposedStep) -> bool

PhpProject_alignLigands(...)
PhpProject_alignLigands(PhpProject self, SwigIntVector ligandIDs, std::string const & hypoID, double deltaDist=2.0, int minSites=3, double siteWeight=1.0, double vectorWeight=1.0, double volumeWeight=1.0) -> SwigIntVector

PhpProject_assignActives(...)
PhpProject_assignActives(PhpProject self, double minAct)

PhpProject_assignDefaultGroups(...)
PhpProject_assignDefaultGroups(PhpProject self)

PhpProject_assignGroups(...)
PhpProject_assignGroups(PhpProject self, SwigStringVector titles) -> SwigVectorIntVector

PhpProject_assignInactives(...)
PhpProject_assignInactives(PhpProject self, double maxAct)

PhpProject_assignQsarSet(...)
PhpProject_assignQsarSet(PhpProject self, int numTrain, int seed=0, bool usePharmSet=False, bool sortByActivity=False)

PhpProject_beforeStep(...)
PhpProject_beforeStep(PhpProject self, std::string const & proposedStep) -> bool

PhpProject_buildQsarModel(...)
PhpProject_buildQsarModel(PhpProject self, std::string const & inFile, std::string const & actProp, std::string const & qsarSetProp, std::string const & trainValue, std::string const & testValue, std::string const & modelStyle, std::string const & pharmFile, std::string const & radFile, int maxFactors, double dgrid, int ncv, double tmin, std::string const & prefix) -> SwigVectorDoubleVector

PhpProject_closeProject(...)
PhpProject_closeProject(PhpProject self)

PhpProject_commitMasterData(...)
PhpProject_commitMasterData(PhpProject self, bool writeFirst=False)

PhpProject_compareFeatureDef(...)
PhpProject_compareFeatureDef(PhpProject self, std::string const & fdFile1, std::string const & fdFile2) -> int

PhpProject_copyFile(...)
PhpProject_copyFile(PhpProject self, std::string const & baseName, std::string const & fromDir, std::string const & toDir, bool mustExist=False)

PhpProject_createSites(...)
PhpProject_createSites(PhpProject self, std::string const & jobName, bool save)

PhpProject_deleteHypotheses(...)
PhpProject_deleteHypotheses(PhpProject self, SwigStringVector hypoIDs)

PhpProject_deleteLigands(...)
PhpProject_deleteLigands(PhpProject self, SwigIntVector ligandIDs)

PhpProject_deleteQsarModels(...)
PhpProject_deleteQsarModels(PhpProject self, SwigStringVector hypoIDs)

PhpProject_expActivity(...)
PhpProject_expActivity(PhpProject self)

PhpProject_getAbsolutePath(...)
PhpProject_getAbsolutePath(PhpProject self, std::string const & path) -> std::string

PhpProject_getActivity(...)
PhpProject_getActivity(PhpProject self, int ligandID, double missingValue=0.0) -> double

PhpProject_getActivityMissing(...)
PhpProject_getActivityMissing(PhpProject self, int ligandID) -> bool

PhpProject_getBindingModes(...)
PhpProject_getBindingModes(PhpProject self, int numModes, SwigStringVector hypoIDs) -> SwigVectorIntVector

PhpProject_getConformer(...)
PhpProject_getConformer(PhpProject self, int ligandID, int confIndex) -> MM_Index

PhpProject_getConformerCount(...)
PhpProject_getConformerCount(PhpProject self, int ligandID) -> int

PhpProject_getConformers(...)
PhpProject_getConformers(PhpProject self, int ligandID) -> SwigIntVector

PhpProject_getDbID(...)
PhpProject_getDbID(PhpProject self, int ligandID) -> int

PhpProject_getDefaultFdFile(...)
PhpProject_getDefaultFdFile(PhpProject self) -> std::string

PhpProject_getDefaultFeatureDef(...)
PhpProject_getDefaultFeatureDef(PhpProject self) -> std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > >

PhpProject_getDefaultFeatureEquiv(...)
PhpProject_getDefaultFeatureEquiv(PhpProject self) -> SwigStringVector

PhpProject_getDefaultFeatureFreq(...)
PhpProject_getDefaultFeatureFreq(PhpProject self) -> PhpFeatureData

PhpProject_getDefaultFeatureRadii(...)
PhpProject_getDefaultFeatureRadii(PhpProject self) -> PhpFeatureData

PhpProject_getDefaultFeatureTol(...)
PhpProject_getDefaultFeatureTol(PhpProject self) -> PhpFeatureData

PhpProject_getDefaultSiteMasks(...)
PhpProject_getDefaultSiteMasks(PhpProject self) -> std::vector< PhpSiteMask,std::allocator< PhpSiteMask > >

PhpProject_getEnergyProp(...)
PhpProject_getEnergyProp(PhpProject self) -> std::string

PhpProject_getFdFile(...)
PhpProject_getFdFile(PhpProject self) -> std::string

PhpProject_getFeatureDef(...)
PhpProject_getFeatureDef(PhpProject self, std::string const & fdFile) -> std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > >

PhpProject_getFeatureDefFromProj(...)
PhpProject_getFeatureDefFromProj(PhpProject self) -> std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > >

PhpProject_getFeatureEquiv(...)
PhpProject_getFeatureEquiv(PhpProject self) -> SwigStringVector

PhpProject_getFeatureFreq(...)
PhpProject_getFeatureFreq(PhpProject self) -> PhpFeatureData

PhpProject_getFeatureRadii(...)
PhpProject_getFeatureRadii(PhpProject self) -> PhpFeatureData

PhpProject_getFeatureTol(...)
PhpProject_getFeatureTol(PhpProject self) -> PhpFeatureData

PhpProject_getGroup(...)
PhpProject_getGroup(PhpProject self, int ligandID) -> int

int

PhpProject_getGroupCount()
PhpProject_getGroupCount(PhpProject self, SwigIntVector ligandIDs) -> int

PhpProject_getHypo(...)
PhpProject_getHypo(PhpProject self, std::string const & hypoID, bool qsar=False) -> PhpHypoAdaptor

PhpProject_getHypoAlignments(...)
PhpProject_getHypoAlignments(PhpProject self, std::string const & hypoID, bool wantMisses=False) -> SwigIntVector

PhpProject_getHypoFmt(...)
PhpProject_getHypoFmt(PhpProject self) -> std::string

PhpProject_getHypoIDs(...)
PhpProject_getHypoIDs(PhpProject self, bool fullPath=False) -> SwigStringVector

PhpProject_getHypoMatches(...)
PhpProject_getHypoMatches(PhpProject self, std::string const & hypoID, bool wantMisses=False) -> SwigVectorStringVector

PhpProject_getHypoScores(...)
PhpProject_getHypoScores(PhpProject self, std::string const & hypoID) -> SwigStringVector

PhpProject_getHypoSites(...)
PhpProject_getHypoSites(PhpProject self, std::string const & hypoID, bool wantProj=False) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpProject_getHypoSitesStrings(...)
PhpProject_getHypoSitesStrings(PhpProject self, std::string const & hypoID, bool wantProj=False) -> SwigVectorStringVector

PhpProject_getInFileType(...)
PhpProject_getInFileType(PhpProject self, std::string const & fileName) -> std::string

PhpProject_getInactiveAlignments(...)
PhpProject_getInactiveAlignments(PhpProject self, std::string const & hypoID, bool allowMissing=False) -> SwigIntVector

PhpProject_getLigand(...)
PhpProject_getLigand(PhpProject self, int ligandID) -> PhpLigand

PhpProject_getLigandCount(...)
PhpProject_getLigandCount(PhpProject self, std::string const & category) -> int

PhpProject_getLigandIDs(...)
PhpProject_getLigandIDs(PhpProject self, std::string const & category) -> SwigIntVector

PhpProject_getMatchedSites(...)
PhpProject_getMatchedSites(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, bool wantProj=False) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpProject_getMatchedSitesStrings(...)
PhpProject_getMatchedSitesStrings(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, bool wantProj=False) -> SwigVectorStringVector

PhpProject_getMolSites(...)
PhpProject_getMolSites(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, bool wantProj=False) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpProject_getMolSitesAtoms(...)
PhpProject_getMolSitesAtoms(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, int offset=1) -> SwigVectorIntVector

PhpProject_getMolSitesStrings(...)
PhpProject_getMolSitesStrings(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, bool wantProj=False) -> SwigVectorStringVector

PhpProject_getMustMatch(...)
PhpProject_getMustMatch(PhpProject self, int ligandID) -> bool

PhpProject_getPatternMatches(...)
PhpProject_getPatternMatches(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd) -> SwigVectorIntVector

PhpProject_getPharmSet(...)
PhpProject_getPharmSet(PhpProject self, int ligandID) -> std::string

PhpProject_getProjectPath(...)
PhpProject_getProjectPath(PhpProject self, bool orig=False) -> std::string

PhpProject_getQsarAlignments(...)
PhpProject_getQsarAlignments(PhpProject self, std::string const & hypoID) -> SwigIntVector

PhpProject_getQsarCount(...)
PhpProject_getQsarCount(PhpProject self, std::string const & category) -> int

PhpProject_getQsarHypoIDs(...)
PhpProject_getQsarHypoIDs(PhpProject self, bool fullPath=False) -> SwigStringVector

PhpProject_getQsarIDs(...)
PhpProject_getQsarIDs(PhpProject self, std::string const & category) -> SwigIntVector

PhpProject_getQsarModel(...)
PhpProject_getQsarModel(PhpProject self, std::string const & qsarFile, bool fromProject=False) -> PhpQSAR

PhpProject_getQsarModelClassDescription(...)
PhpProject_getQsarModelClassDescription(PhpProject self, PhpQSAR qsar, std::string const & qsarClass) -> std::string

PhpProject_getQsarModelClassFraction(...)
PhpProject_getQsarModelClassFraction(PhpProject self, PhpQSAR qsar, std::string const & qsarClass, int numFactors) -> double

PhpProject_getQsarModelClasses(...)
PhpProject_getQsarModelClasses(PhpProject self, PhpQSAR qsar) -> SwigStringVector

PhpProject_getQsarModelCoeff(...)
getQsarModelCoeff(PhpQSAR qsar, int numFactors, bool combineClasses=False) -> SwigDoubleVector getQsarModelCoeff(PhpQSAR qsar, int numFactors, std::string const & qsarClass) -> SwigDoubleVector PhpProject_getQsarModelCoeff(PhpProject self, PhpQSAR qsar, int numFactors, SwigStringVector qsarClasses, bool combineClasses=False) -> SwigDoubleVector

PhpProject_getQsarModelCoeffRange(...)
getQsarModelCoeffRange(PhpQSAR qsar, int numFactors, bool combineClasses=False) -> SwigDoubleVector getQsarModelCoeffRange(PhpQSAR qsar, int numFactors, std::string const & qsarClass) -> SwigDoubleVector PhpProject_getQsarModelCoeffRange(PhpProject self, PhpQSAR qsar, int numFactors, SwigStringVector qsarClasses, bool combineClasses=False) -> SwigDoubleVector

PhpProject_getQsarModelFactorCount(...)
PhpProject_getQsarModelFactorCount(PhpProject self, PhpQSAR qsar) -> int

PhpProject_getQsarModelGridLimits(...)
PhpProject_getQsarModelGridLimits(PhpProject self, PhpQSAR qsar) -> SwigDoubleVector

PhpProject_getQsarModelGridSpacing(...)
PhpProject_getQsarModelGridSpacing(PhpProject self, PhpQSAR qsar) -> double

PhpProject_getQsarModelRegF(...)
PhpProject_getQsarModelRegF(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegP(...)
PhpProject_getQsarModelRegP(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegRsqr(...)
PhpProject_getQsarModelRegRsqr(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegRsqrCv(...)
PhpProject_getQsarModelRegRsqrCv(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegRsqrScramble(...)
PhpProject_getQsarModelRegRsqrScramble(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegSD(...)
PhpProject_getQsarModelRegSD(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelRegStability(...)
PhpProject_getQsarModelRegStability(PhpProject self, PhpQSAR qsar, int numFactors) -> double

PhpProject_getQsarModelStyle(...)
PhpProject_getQsarModelStyle(PhpProject self, PhpQSAR qsar) -> std::string

PhpProject_getQsarModelVolBitCount(...)
getQsarModelVolBitCount(PhpQSAR qsar) -> int getQsarModelVolBitCount(PhpQSAR qsar, std::string const & qsarClass) -> int PhpProject_getQsarModelVolBitCount(PhpProject self, PhpQSAR qsar, SwigStringVector qsarClasses) -> int

PhpProject_getQsarModelVolClasses(...)
PhpProject_getQsarModelVolClasses(PhpProject self, PhpQSAR qsar) -> SwigStringVector

PhpProject_getQsarModelVolCoords(...)
getQsarModelVolCoords(PhpQSAR qsar) -> SwigVectorDoubleVector getQsarModelVolCoords(PhpQSAR qsar, std::string const & qsarClass) -> SwigVectorDoubleVector PhpProject_getQsarModelVolCoords(PhpProject self, PhpQSAR qsar, SwigStringVector qsarClasses) -> SwigVectorDoubleVector

PhpProject_getQsarModelVolOnBits(...)
getQsarModelVolOnBits(PhpQSAR qsar, MM_Index ctHandle) -> SwigIntVector getQsarModelVolOnBits(PhpQSAR qsar, MM_Index ctHandle, std::string const & qsarClass) -> SwigIntVector PhpProject_getQsarModelVolOnBits(PhpProject self, PhpQSAR qsar, MM_Index ctHandle, SwigStringVector qsarClasses) -> SwigIntVector

PhpProject_getQsarProps(...)
PhpProject_getQsarProps(PhpProject self, MM_Index & ctHandle) -> SwigStringVector

PhpProject_getQsarSet(...)
PhpProject_getQsarSet(PhpProject self, int ligandID) -> std::string

PhpProject_getQsarStats(...)
PhpProject_getQsarStats(PhpProject self, std::string const & hypoID) -> SwigVectorDoubleVector

PhpProject_getRuntimeName(...)
PhpProject_getRuntimeName(PhpProject self, std::string const & fileName) -> std::string

PhpProject_getSiteMappings(...)
PhpProject_getSiteMappings(PhpProject self, PhpSite site, std::vector< PhpSite,std::allocator< PhpSite > > const & pool, int maxMap=1, double tol=0.001, bool matchType=True, bool matchNumber=False) -> SwigIntVector

PhpProject_getSiteMasks(...)
PhpProject_getSiteMasks(PhpProject self, bool ignoreDiffs=False) -> std::vector< PhpSiteMask,std::allocator< PhpSiteMask > >

PhpProject_getSitesConformer(...)
PhpProject_getSitesConformer(PhpProject self, int ligandID, int confIndex) -> std::vector< PhpSite,std::allocator< PhpSite > >

PhpProject_getSitesConformers(...)
PhpProject_getSitesConformers(PhpProject self, int ligandID) -> std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > >

PhpProject_getSlash(...)
PhpProject_getSlash(PhpProject self) -> std::string

PhpProject_getStep(...)
PhpProject_getStep(PhpProject self) -> std::string

PhpProject_getTitle(...)
PhpProject_getTitle(PhpProject self, int ligandID) -> std::string

PhpProject_haveMasterDiffs(...)
PhpProject_haveMasterDiffs(PhpProject self, bool ignoreQsar=False) -> bool

PhpProject_isValidArchiveName(...)
PhpProject_isValidArchiveName(PhpProject self, std::string const & projectArchive) -> bool

PhpProject_isValidProjectName(...)
PhpProject_isValidProjectName(PhpProject self, std::string const & projectName) -> bool

PhpProject_logActivity(...)
PhpProject_logActivity(PhpProject self)

PhpProject_mapSites(...)
PhpProject_mapSites(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, std::vector< PhpSite,std::allocator< PhpSite > > * sites, SwigVectorIntVector atoms, bool wantProj=False)

PhpProject_needSyncFeatureDef(...)
PhpProject_needSyncFeatureDef(PhpProject self) -> bool

PhpProject_newProject(...)
newProject(std::string const & projectName, std::string const & inFile, std::string const & fdFile, bool connect, bool stereo, std::string const & titleProp, std::string const & actProp, std::string const & jobName, bool save, std::string hypoFmt, std::string energyProp) PhpProject_newProject(PhpProject self, std::string const & projectName, std::string const & sourceProjectName, SwigIntVector ligandIDs, std::string const & fdFile, std::string const & actProp, std::string const & jobName, bool save, std::string hypoFmt, std::string energyProp)

PhpProject_normalizeFeatureEquiv(...)
PhpProject_normalizeFeatureEquiv(PhpProject self, SwigStringVector featureEquiv) -> SwigStringVector

PhpProject_openProject(...)
PhpProject_openProject(PhpProject self, std::string const & projectName, bool checkMaster=False)

PhpProject_restoreMasterData(...)
PhpProject_restoreMasterData(PhpProject self)

PhpProject_reviseDatabase(...)
PhpProject_reviseDatabase(PhpProject self, std::string const & jobName, std::string const & reviseOptions, bool save)

PhpProject_sampleActives(...)
PhpProject_sampleActives(PhpProject self, int sampleSize, bool includeNone=False)

PhpProject_saveFeatureDef(...)
PhpProject_saveFeatureDef(PhpProject self, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd)

PhpProject_saveFeatureDefToFile(...)
PhpProject_saveFeatureDefToFile(PhpProject self, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, std::string const & fdFile)

PhpProject_saveFeatureEquiv(...)
PhpProject_saveFeatureEquiv(PhpProject self, SwigStringVector featureEquiv)

PhpProject_saveFeatureFreq(...)
PhpProject_saveFeatureFreq(PhpProject self, PhpFeatureData featureFreq)

PhpProject_saveFeatureRadii(...)
PhpProject_saveFeatureRadii(PhpProject self, PhpFeatureData featureRadii)

PhpProject_saveFeatureTol(...)
PhpProject_saveFeatureTol(PhpProject self, PhpFeatureData featureTol)

PhpProject_saveFind(...)
PhpProject_saveFind(PhpProject self, std::string const & jobName)

PhpProject_saveMasterData(...)
PhpProject_saveMasterData(PhpProject self)

PhpProject_saveQsar(...)
PhpProject_saveQsar(PhpProject self, std::string const & jobName)

PhpProject_saveSiteMasks(...)
PhpProject_saveSiteMasks(PhpProject self, std::vector< PhpSiteMask,std::allocator< PhpSiteMask > > const & siteMasks)

PhpProject_scaleActivity(...)
PhpProject_scaleActivity(PhpProject self, double scale)

PhpProject_setActivity(...)
PhpProject_setActivity(PhpProject self, int ligandID, double activity)

PhpProject_setActivityMissing(...)
PhpProject_setActivityMissing(PhpProject self, int ligandID)

PhpProject_setGroup(...)
PhpProject_setGroup(PhpProject self, int ligandID, int group)

PhpProject_setMustMatch(...)
PhpProject_setMustMatch(PhpProject self, int ligandID, bool mustMatch)

PhpProject_setPharmSet(...)
PhpProject_setPharmSet(PhpProject self, int ligandID, std::string const & pharmSet)

PhpProject_setQsarSet(...)
PhpProject_setQsarSet(PhpProject self, int ligandID, std::string const & qsarSet)

PhpProject_setupFind(...)
PhpProject_setupFind(PhpProject self, std::string const & directory) -> std::string

PhpProject_setupQsar(...)
PhpProject_setupQsar(PhpProject self, std::string const & directory) -> std::string

PhpProject_siteToStrings(...)
PhpProject_siteToStrings(PhpProject self, PhpSite site) -> SwigStringVector

PhpProject_swiginit(...)

PhpProject_swigregister(...)

PhpProject_syncFeatureDef(...)
PhpProject_syncFeatureDef(PhpProject self)

PhpProject_testQsarModel(...)
PhpProject_testQsarModel(PhpProject self, PhpQSAR qsar, std::string const & inFile, std::string const & actProp, std::string const & prefix) -> SwigVectorDoubleVector

PhpProject_unzipArchive(...)
PhpProject_unzipArchive(PhpProject self, std::string const & directory, std::string const & archive)

PhpProject_unzipProject(...)
PhpProject_unzipProject(PhpProject self, std::string const & directory, std::string const & projectArchive) -> std::string

PhpProject_writeHypoFiles(...)
PhpProject_writeHypoFiles(PhpProject self, std::string const & hypoID, MM_Index refCt, std::vector< PhpSite,std::allocator< PhpSite > > const & hypoSites, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd)

PhpProject_writeSummary(...)
PhpProject_writeSummary(PhpProject self, std::ostream & os)

PhpProject_zipDirectory(...)
PhpProject_zipDirectory(PhpProject self, std::string const & directory, std::string const & archive)

PhpProject_zipProject(...)
PhpProject_zipProject(PhpProject self, std::string const & directory, std::string const & projectName, bool create=True) -> std::string

PhpQSARModel_atomClasses_get(...)
PhpQSARModel_atomClasses_get(PhpQSARModel self) -> SwigStringVector

PhpQSARModel_atomClasses_set(...)
PhpQSARModel_atomClasses_set(PhpQSARModel self, SwigStringVector atomClasses)

PhpQSARModel_classFractions_get(...)
PhpQSARModel_classFractions_get(PhpQSARModel self) -> std::map< std::string,std::vector< double,std::allocator< double > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::vector< double,std::allocator< double > > > > > *

PhpQSARModel_classFractions_set(...)
PhpQSARModel_classFractions_set(PhpQSARModel self, std::map< std::string,std::vector< double,std::allocator< double > >,std::less< std::string >,std::allocator< std::pair< std::string const,std::vector< double,std::allocator< double > > > > > * classFractions)

PhpQSARModel_featureRadii_get(...)
PhpQSARModel_featureRadii_get(PhpQSARModel self) -> PhpFeatureData

PhpQSARModel_featureRadii_set(...)
PhpQSARModel_featureRadii_set(PhpQSARModel self, PhpFeatureData featureRadii)

PhpQSARModel_gridSpacing_get(...)
PhpQSARModel_gridSpacing_get(PhpQSARModel self) -> double

PhpQSARModel_gridSpacing_set(...)
PhpQSARModel_gridSpacing_set(PhpQSARModel self, double gridSpacing)

PhpQSARModel_numBitsByClass_get(...)
PhpQSARModel_numBitsByClass_get(PhpQSARModel self) -> std::map< std::string,size_t,std::less< std::string >,std::allocator< std::pair< std::string const,size_t > > > *

PhpQSARModel_numBitsByClass_set(...)
PhpQSARModel_numBitsByClass_set(PhpQSARModel self, std::map< std::string,size_t,std::less< std::string >,std::allocator< std::pair< std::string const,size_t > > > * numBitsByClass)

PhpQSARModel_pls_get(...)
PhpQSARModel_pls_get(PhpQSARModel self) -> PhpPLS

PhpQSARModel_pls_set(...)
PhpQSARModel_pls_set(PhpQSARModel self, PhpPLS pls)

PhpQSARModel_rsqrScramble_get(...)
PhpQSARModel_rsqrScramble_get(PhpQSARModel self) -> SwigDoubleVector

PhpQSARModel_rsqrScramble_set(...)
PhpQSARModel_rsqrScramble_set(PhpQSARModel self, SwigDoubleVector rsqrScramble)

PhpQSARModel_swiginit(...)

PhpQSARModel_swigregister(...)

PhpQSARModel_volumeNames_get(...)
PhpQSARModel_volumeNames_get(PhpQSARModel self) -> SwigStringVector

PhpQSARModel_volumeNames_set(...)
PhpQSARModel_volumeNames_set(PhpQSARModel self, SwigStringVector volumeNames)

PhpQSARModel_xmax_get(...)
PhpQSARModel_xmax_get(PhpQSARModel self) -> double

PhpQSARModel_xmax_set(...)
PhpQSARModel_xmax_set(PhpQSARModel self, double xmax)

PhpQSARModel_xmin_get(...)
PhpQSARModel_xmin_get(PhpQSARModel self) -> double

PhpQSARModel_xmin_set(...)
PhpQSARModel_xmin_set(PhpQSARModel self, double xmin)

PhpQSARModel_ymax_get(...)
PhpQSARModel_ymax_get(PhpQSARModel self) -> double

PhpQSARModel_ymax_set(...)
PhpQSARModel_ymax_set(PhpQSARModel self, double ymax)

PhpQSARModel_ymin_get(...)
PhpQSARModel_ymin_get(PhpQSARModel self) -> double

PhpQSARModel_ymin_set(...)
PhpQSARModel_ymin_set(PhpQSARModel self, double ymin)

PhpQSARModel_zmax_get(...)
PhpQSARModel_zmax_get(PhpQSARModel self) -> double

PhpQSARModel_zmax_set(...)
PhpQSARModel_zmax_set(PhpQSARModel self, double zmax)

PhpQSARModel_zmin_get(...)
PhpQSARModel_zmin_get(PhpQSARModel self) -> double

PhpQSARModel_zmin_set(...)
PhpQSARModel_zmin_set(PhpQSARModel self, double zmin)

PhpQSAR_clear(...)
PhpQSAR_clear(PhpQSAR self)

PhpQSAR_clearDataSet(...)
PhpQSAR_clearDataSet(PhpQSAR self)

PhpQSAR_clearModel(...)
PhpQSAR_clearModel(PhpQSAR self)

PhpQSAR_computeRCorr(...)
PhpQSAR_computeRCorr(PhpQSAR self, SwigDoubleVector x, SwigDoubleVector y) -> double

PhpQSAR_computeStats(...)
PhpQSAR_computeStats(PhpQSAR self, SwigDoubleVector yobs, SwigDoubleVector ypred, double & varObs, double & varPred, double & rmsErr, double & qsqr, double & rcorr)

PhpQSAR_createModel(...)
createModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, SwigSizetVector trainList, double gridSpacing, double dbuff, size_t maxFactors) -> int PhpQSAR_createModel(PhpQSAR self, SwigSizetVector trainList, double gridSpacing, double dbuff, size_t maxFactors) -> int

PhpQSAR_crossValidateModel(...)
crossValidateModel(size_t n, size_t randSeed, SwigVectorDoubleVector yhatLNO, SwigDoubleVector rsqrYobs, SwigDoubleVector rsqrYhat) -> int crossValidateModel(size_t n, size_t randSeed, SwigDoubleVector rsqrYobs, SwigDoubleVector rsqrYhat) -> int PhpQSAR_crossValidateModel(PhpQSAR self, size_t n, size_t randSeed) -> int

PhpQSAR_duplexDataSet(...)
duplexDataSet(size_t numTotal, size_t numTrain, size_t & randomSeed, SwigSizetVector trainList, SwigSizetVector predList) PhpQSAR_duplexDataSet(PhpQSAR self, size_t numTrain, size_t & randomSeed, SwigDoubleVector activities, SwigSizetVector trainList, SwigSizetVector predList)

PhpQSAR_exportModel(...)
PhpQSAR_exportModel(PhpQSAR self, std::string const & modelFile) -> int

PhpQSAR_exportModelToStream(...)
PhpQSAR_exportModelToStream(PhpQSAR self, std::ostream & modelStream)

PhpQSAR_getActivities(...)
PhpQSAR_getActivities(PhpQSAR self) -> SwigDoubleVector

PhpQSAR_getAtomClassDescription(...)
PhpQSAR_getAtomClassDescription(PhpQSAR self, std::string const & atomClass) -> std::string

PhpQSAR_getAtomClasses(...)
PhpQSAR_getAtomClasses(PhpQSAR self) -> SwigStringVector

PhpQSAR_getClassFraction(...)
PhpQSAR_getClassFraction(PhpQSAR self, std::string const & atomClass, size_t numFactors) -> double

PhpQSAR_getModel(...)
PhpQSAR_getModel(PhpQSAR self) -> PhpQSARModel

PhpQSAR_getModelType(...)
PhpQSAR_getModelType(PhpQSAR self) -> std::string

PhpQSAR_getMoleculeType(...)
PhpQSAR_getMoleculeType(PhpQSAR self) -> std::string

PhpQSAR_getMolecules(...)
PhpQSAR_getMolecules(PhpQSAR self) -> std::vector< PhpMolModel,std::allocator< PhpMolModel > >

PhpQSAR_getOnBits(...)
PhpQSAR_getOnBits(PhpQSAR self, SwigSizetVector bits) -> SwigSizetVector

PhpQSAR_getRegF(...)
PhpQSAR_getRegF(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegP(...)
PhpQSAR_getRegP(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegRsqr(...)
PhpQSAR_getRegRsqr(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegRsqrCv(...)
PhpQSAR_getRegRsqrCv(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegRsqrScramble(...)
PhpQSAR_getRegRsqrScramble(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegSD(...)
PhpQSAR_getRegSD(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getRegStability(...)
PhpQSAR_getRegStability(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getTestRCorr(...)
PhpQSAR_getTestRCorr(PhpQSAR self, size_t numFactors) -> double

PhpQSAR_getTitles(...)
PhpQSAR_getTitles(PhpQSAR self) -> SwigStringVector

PhpQSAR_getTvalue(...)
PhpQSAR_getTvalue(PhpQSAR self, double p, size_t ndf) -> double

PhpQSAR_getVectSubset(...)
PhpQSAR_getVectSubset(PhpQSAR self, SwigDoubleVector v, SwigSizetVector subset) -> SwigDoubleVector

PhpQSAR_getVolAtomClasses(...)
PhpQSAR_getVolAtomClasses(PhpQSAR self) -> SwigStringVector

std::vector< PhpVolCoords,std::allocator< PhpVolCoords > >

PhpQSAR_getVolCoords()
getVolCoords(std::string const & atomClass) -> std::vector< PhpVolCoords,std::allocator< PhpVolCoords > > PhpQSAR_getVolCoords(PhpQSAR self, SwigStringVector atomClasses) -> std::vector< PhpVolCoords,std::allocator< PhpVolCoords > >

PhpQSAR_getVolOccBits(...)
getVolOccBits(PhpMolModel const & molModel) -> SwigSizetVector getVolOccBits(size_t imol) -> SwigSizetVector getVolOccBits(PhpMolModel const & molModel, std::string const & atomClass) -> SwigSizetVector getVolOccBits(size_t imol, std::string const & atomClass) -> SwigSizetVector getVolOccBits(PhpMolModel const & molModel, SwigStringVector atomClasses) -> SwigSizetVector PhpQSAR_getVolOccBits(PhpQSAR self, size_t imol, SwigStringVector atomClasses) -> SwigSizetVector

PhpQSAR_getVolRegCoeffs(...)
getVolRegCoeffs(size_t numFactors, bool combineAtomClasses=False) -> SwigDoubleVector getVolRegCoeffs(size_t numFactors, std::string const & atomClass) -> SwigDoubleVector PhpQSAR_getVolRegCoeffs(PhpQSAR self, size_t numFactors, SwigStringVector atomClasses, bool combineAtomClasses=False) -> SwigDoubleVector

PhpQSAR_importActivities(...)
importActivities(char const * actFile) -> int PhpQSAR_importActivities(PhpQSAR self, SwigDoubleVector activities)

PhpQSAR_importModel(...)
importModel(std::string const & modelFile) -> int PhpQSAR_importModel(PhpQSAR self, std::istream & modelStream) -> int

PhpQSAR_importMolecules(...)
importMolecules(char const * maeFile) -> int PhpQSAR_importMolecules(PhpQSAR self, SwigIntVector ctHandles)

PhpQSAR_importMoleculesAndActivities(...)
PhpQSAR_importMoleculesAndActivities(PhpQSAR self, char const * maeFile, char const * activityProperty, double missingActivity=0.0) -> int

PhpQSAR_importPharm(...)
importPharm(char const * pharmFile, char const * featureRadiusFile=None) -> int PhpQSAR_importPharm(PhpQSAR self, std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > > const & pharmVect) -> int

PhpQSAR_numActivities(...)
PhpQSAR_numActivities(PhpQSAR self) -> size_t

PhpQSAR_numMolecules(...)
PhpQSAR_numMolecules(PhpQSAR self) -> size_t

PhpQSAR_numPLSFactors(...)
PhpQSAR_numPLSFactors(PhpQSAR self) -> size_t

size_t

PhpQSAR_numVolBits()
numVolBits(std::string const & atomClass) -> size_t PhpQSAR_numVolBits(PhpQSAR self, SwigStringVector atomClasses) -> size_t

PhpQSAR_printDelimitedActivities(...)
PhpQSAR_printDelimitedActivities(PhpQSAR self, std::ostream & outStream, SwigSizetVector observations, SwigStringVector qsarSet, std::string const & delim, bool printHeaders=True)

PhpQSAR_printDelimitedBits(...)
PhpQSAR_printDelimitedBits(PhpQSAR self, std::ostream & outStream, SwigSizetVector observations, SwigStringVector qsarSet, std::string const & delim, bool printHeaders=True)

PhpQSAR_printModel(...)
PhpQSAR_printModel(PhpQSAR self, std::ostream & outStream, bool printVolumeBits=True)

PhpQSAR_printPred(...)
printPred(std::ostream & outStream, std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, SwigSizetVector predList, bool trainingSet=False) PhpQSAR_printPred(PhpQSAR self, std::ostream & outStream, SwigSizetVector predList, bool trainingSet=False)

PhpQSAR_printVolOccBits(...)
printVolOccBits(std::ostream & outStream, std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigSizetVector molList) printVolOccBits(std::ostream & outStream, SwigSizetVector molList) PhpQSAR_printVolOccBits(PhpQSAR self, std::ostream & outStream)

PhpQSAR_setTvalueFilterOff(...)
PhpQSAR_setTvalueFilterOff(PhpQSAR self)

PhpQSAR_setTvalueFilterOn(...)
PhpQSAR_setTvalueFilterOn(PhpQSAR self, double tmin, size_t n, size_t seed)

PhpQSAR_swiginit(...)

PhpQSAR_swigregister(...)

PhpQSAR_testModel(...)
testModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, SwigSizetVector predList, size_t numFactors, SwigDoubleVector predActivities, double & rmsErr, double & qsqr) testModel(SwigSizetVector predList, size_t numFactors, SwigDoubleVector predActivities, double & rmsErr, double & qsqr) testModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, std::vector< PhpMolVolume,std::allocator< PhpMolVolume > > & molVolumes, SwigDoubleVector activities, SwigSizetVector predList, size_t numFactors, bool restorePatterns, SwigDoubleVector predActivities, double & rmsErr, double & qsqr) testModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, SwigSizetVector predList, size_t numFactors1, size_t numFactors2, SwigVectorDoubleVector predActivities, SwigDoubleVector rmsErr, SwigDoubleVector qsqr) PhpQSAR_testModel(PhpQSAR self, SwigSizetVector predList, size_t numFactors1, size_t numFactors2, SwigVectorDoubleVector predActivities, SwigDoubleVector rmsErr, SwigDoubleVector qsqr)

PhpSiteConstrainer_addConstraint(...)
PhpSiteConstrainer_addConstraint(PhpSiteConstrainer self, PhpSiteConstraint constraint)

PhpSiteConstrainer_clear(...)
PhpSiteConstrainer_clear(PhpSiteConstrainer self)

PhpSiteConstrainer_exportConstraints(...)
exportConstraints(std::string const & outFile) PhpSiteConstrainer_exportConstraints(PhpSiteConstrainer self, std::ostream & outStream)

PhpSiteConstrainer_getConstraint(...)
PhpSiteConstrainer_getConstraint(PhpSiteConstrainer self, size_t i, size_t numSites) -> PhpSiteConstraint

PhpSiteConstrainer_getConstraintValue(...)
PhpSiteConstrainer_getConstraintValue(PhpSiteConstrainer self, std::vector< PhpSite,std::allocator< PhpSite > > const & sites) -> double

std::vector< PhpSiteConstraint,std::allocator< PhpSiteConstraint > >

PhpSiteConstrainer_getConstraints()
PhpSiteConstrainer_getConstraints(PhpSiteConstrainer self, size_t numSites) -> std::vector< PhpSiteConstraint,std::allocator< PhpSiteConstraint > >

PhpSiteConstrainer_hasProjectedSites(...)
PhpSiteConstrainer_hasProjectedSites(PhpSiteConstrainer self) -> bool

PhpSiteConstrainer_importConstraints(...)
importConstraints(std::string const & inFile) PhpSiteConstrainer_importConstraints(PhpSiteConstrainer self, std::istream & inStream)

size_t

PhpSiteConstrainer_numConstraints()
PhpSiteConstrainer_numConstraints(PhpSiteConstrainer self, size_t numSites) -> size_t

PhpSiteConstrainer_passes(...)
passes(std::vector< PhpSite,std::allocator< PhpSite > > const & sites, PhpSiteConstraint constraint) -> bool passes(std::vector< PhpSite,std::allocator< PhpSite > > const & hypoSites, std::string & reason) -> bool passes(std::vector< PhpSite,std::allocator< PhpSite > > const & hypoSites, PhpLigand const & refLigand, size_t refConfIndex, std::string & reason) -> bool passes(PhpLigand const & refLigand, size_t refConfIndex, SwigSizetVector refSiteIndices, PhpLigand const & matchedLigand, size_t matchedConfIndex, SwigSizetVector matchedSiteIndices, std::vector< PhpSite,std::allocator< PhpSite > > & refSitesNeeded, std::string & reason) -> bool PhpSiteConstrainer_passes(PhpSiteConstrainer self, std::vector< PhpSite,std::allocator< PhpSite > > const & hypoSites, bool checkHypoSites, PhpLigand const & matchedLigand, size_t matchedConfIndex, SwigSizetVector matchedSiteIndices, std::string & reason) -> bool

PhpSiteConstrainer_printConstraint(...)
PhpSiteConstrainer_printConstraint(PhpSiteConstrainer self, PhpSiteConstraint constraint, std::ostream & outStream)

PhpSiteConstrainer_swiginit(...)

PhpSiteConstrainer_swigregister(...)

PhpSiteConstraint_getSiteIndices(...)
PhpSiteConstraint_getSiteIndices(PhpSiteConstraint self) -> SwigIntVector

PhpSiteConstraint_getSiteTypes(...)
PhpSiteConstraint_getSiteTypes(PhpSiteConstraint self) -> std::string

PhpSiteConstraint_getTol(...)
PhpSiteConstraint_getTol(PhpSiteConstraint self) -> double

PhpSiteConstraint_getValue(...)
PhpSiteConstraint_getValue(PhpSiteConstraint self) -> double

PhpSiteConstraint_setConstraint(...)
PhpSiteConstraint_setConstraint(PhpSiteConstraint self, SwigIntVector u_siteIndices, std::string const & u_siteTypes, double u_value, double u_tol)

PhpSiteConstraint_siteIndices_get(...)
PhpSiteConstraint_siteIndices_get(PhpSiteConstraint self) -> SwigSizetVector

PhpSiteConstraint_siteIndices_set(...)
PhpSiteConstraint_siteIndices_set(PhpSiteConstraint self, SwigSizetVector siteIndices)

PhpSiteConstraint_siteTypes_get(...)
PhpSiteConstraint_siteTypes_get(PhpSiteConstraint self) -> std::string const &

PhpSiteConstraint_siteTypes_set(...)
PhpSiteConstraint_siteTypes_set(PhpSiteConstraint self, std::string const & siteTypes)

PhpSiteConstraint_swiginit(...)

PhpSiteConstraint_swigregister(...)

PhpSiteConstraint_tol_get(...)
PhpSiteConstraint_tol_get(PhpSiteConstraint self) -> double

PhpSiteConstraint_tol_set(...)
PhpSiteConstraint_tol_set(PhpSiteConstraint self, double tol)

PhpSiteConstraint_value_get(...)
PhpSiteConstraint_value_get(PhpSiteConstraint self) -> double

PhpSiteConstraint_value_set(...)
PhpSiteConstraint_value_set(PhpSiteConstraint self, double value)

PhpSiteMaskData_getMaskValue(...)
PhpSiteMaskData_getMaskValue(PhpSiteMaskData self) -> int

PhpSiteMaskData_getSiteNumber(...)
PhpSiteMaskData_getSiteNumber(PhpSiteMaskData self) -> int

PhpSiteMaskData_getSiteType(...)
PhpSiteMaskData_getSiteType(PhpSiteMaskData self) -> char

PhpSiteMaskData_maskValue_get(...)
PhpSiteMaskData_maskValue_get(PhpSiteMaskData self) -> int

PhpSiteMaskData_maskValue_set(...)
PhpSiteMaskData_maskValue_set(PhpSiteMaskData self, int maskValue)

PhpSiteMaskData_setData(...)
PhpSiteMaskData_setData(PhpSiteMaskData self, int u_siteNumber, char u_site, int u_maskValue)

PhpSiteMaskData_siteNumber_get(...)
PhpSiteMaskData_siteNumber_get(PhpSiteMaskData self) -> size_t

PhpSiteMaskData_siteNumber_set(...)
PhpSiteMaskData_siteNumber_set(PhpSiteMaskData self, size_t siteNumber)

PhpSiteMaskData_siteType_get(...)
PhpSiteMaskData_siteType_get(PhpSiteMaskData self) -> char

PhpSiteMaskData_siteType_set(...)
PhpSiteMaskData_siteType_set(PhpSiteMaskData self, char siteType)

PhpSiteMaskData_swiginit(...)

PhpSiteMaskData_swigregister(...)

PhpSiteMaskGroup_getGroupNumber(...)
PhpSiteMaskGroup_getGroupNumber(PhpSiteMaskGroup self) -> int

PhpSiteMaskGroup_getMinMatch(...)
PhpSiteMaskGroup_getMinMatch(PhpSiteMaskGroup self) -> int

PhpSiteMaskGroup_getSiteIndices(...)
PhpSiteMaskGroup_getSiteIndices(PhpSiteMaskGroup self) -> SwigIntVector

PhpSiteMaskGroup_groupNumber_get(...)
PhpSiteMaskGroup_groupNumber_get(PhpSiteMaskGroup self) -> size_t

PhpSiteMaskGroup_groupNumber_set(...)
PhpSiteMaskGroup_groupNumber_set(PhpSiteMaskGroup self, size_t groupNumber)

PhpSiteMaskGroup_minMatch_get(...)
PhpSiteMaskGroup_minMatch_get(PhpSiteMaskGroup self) -> size_t

PhpSiteMaskGroup_minMatch_set(...)
PhpSiteMaskGroup_minMatch_set(PhpSiteMaskGroup self, size_t minMatch)

PhpSiteMaskGroup_setGroup(...)
PhpSiteMaskGroup_setGroup(PhpSiteMaskGroup self, SwigIntVector u_siteIndices, int u_minMatch, int u_groupNumber)

PhpSiteMaskGroup_siteIndices_get(...)
PhpSiteMaskGroup_siteIndices_get(PhpSiteMaskGroup self) -> SwigSizetVector

PhpSiteMaskGroup_siteIndices_set(...)
PhpSiteMaskGroup_siteIndices_set(PhpSiteMaskGroup self, SwigSizetVector siteIndices)

PhpSiteMaskGroup_swiginit(...)

PhpSiteMaskGroup_swigregister(...)

PhpSiteMask_addSiteMaskData(...)
addSiteMaskData(size_t siteNumber, char siteType, int maskValue) PhpSiteMask_addSiteMaskData(PhpSiteMask self, PhpSiteMaskData siteMaskData)

PhpSiteMask_addSiteMaskGroup(...)
addSiteMaskGroup(SwigSizetVector siteIndices, size_t minMatch) PhpSiteMask_addSiteMaskGroup(PhpSiteMask self, PhpSiteMaskGroup group)

PhpSiteMask_clear(...)
PhpSiteMask_clear(PhpSiteMask self)

PhpSiteMask_clearSiteMaskGroups(...)
PhpSiteMask_clearSiteMaskGroups(PhpSiteMask self)

PhpSiteMask_exportToFile(...)
PhpSiteMask_exportToFile(PhpSiteMask self, std::string const & fileName)

PhpSiteMask_exportToStream(...)
PhpSiteMask_exportToStream(PhpSiteMask self, std::ostream & outStream)

PhpSiteMask_getMatchLimits(...)
PhpSiteMask_getMatchLimits(SwigIntVector siteMask) -> SwigIntVector

PhpSiteMask_getSiteMaskData(...)
PhpSiteMask_getSiteMaskData(PhpSiteMask self, size_t siteIndex) -> PhpSiteMaskData

PhpSiteMask_getSiteMaskGroups(...)
PhpSiteMask_getSiteMaskGroups(PhpSiteMask self) -> std::vector< PhpSiteMaskGroup,std::allocator< PhpSiteMaskGroup > >

PhpSiteMask_getSiteMaskValue(...)
PhpSiteMask_getSiteMaskValue(PhpSiteMask self, size_t siteIndex) -> int

PhpSiteMask_getSiteMaskVector(...)
PhpSiteMask_getSiteMaskVector(PhpSiteMask self) -> SwigIntVector

PhpSiteMask_getSiteNumber(...)
PhpSiteMask_getSiteNumber(PhpSiteMask self, size_t siteIndex) -> size_t

PhpSiteMask_getSiteType(...)
PhpSiteMask_getSiteType(PhpSiteMask self, size_t siteIndex) -> char

PhpSiteMask_importFromFile(...)
PhpSiteMask_importFromFile(PhpSiteMask self, std::string const & fileName)

PhpSiteMask_importFromStream(...)
PhpSiteMask_importFromStream(PhpSiteMask self, std::istream & inStream)

PhpSiteMask_numSites(...)
PhpSiteMask_numSites(PhpSiteMask self) -> size_t

PhpSiteMask_resolveMaskValue(...)
PhpSiteMask_resolveMaskValue(int maskValue, size_t & groupNumber, size_t & minMatch)

PhpSiteMask_resolveMatchLimits(...)
PhpSiteMask_resolveMatchLimits(SwigIntVector siteMask, size_t & minSites, size_t & maxSites)

PhpSiteMask_splitMaskValue(...)
PhpSiteMask_splitMaskValue(int maskValue) -> SwigIntVector

PhpSiteMask_swiginit(...)

PhpSiteMask_swigregister(...)

PhpSiteWithAtoms_atoms_get(...)
PhpSiteWithAtoms_atoms_get(PhpSiteWithAtoms self) -> std::set< int >

PhpSiteWithAtoms_atoms_set(...)
PhpSiteWithAtoms_atoms_set(PhpSiteWithAtoms self, std::set< int > atoms)

PhpSiteWithAtoms_site_get(...)
PhpSiteWithAtoms_site_get(PhpSiteWithAtoms self) -> PhpSite

PhpSiteWithAtoms_site_set(...)
PhpSiteWithAtoms_site_set(PhpSiteWithAtoms self, PhpSite site)

PhpSiteWithAtoms_swiginit(...)

PhpSiteWithAtoms_swigregister(...)

PhpSite___eq__(...)
PhpSite___eq__(PhpSite self, PhpSite arg3) -> bool

PhpSite___ne__(...)
PhpSite___ne__(PhpSite self, PhpSite rhs) -> bool

PhpSite_calculateSimilarity(...)
PhpSite_calculateSimilarity(PhpSite self, PhpSite rhs) -> double

PhpSite_distance(...)
PhpSite_distance(PhpSite self, PhpSite rhs) -> double

PhpSite_getCoordinates(...)
PhpSite_getCoordinates(PhpSite self) -> SwigDoubleVector

PhpSite_getDisplayName(...)
PhpSite_getDisplayName(PhpSite self) -> std::string

PhpSite_getFragType(...)
PhpSite_getFragType(PhpSite self) -> std::string

PhpSite_getMaskValue(...)
PhpSite_getMaskValue(PhpSite self) -> int

PhpSite_getPermitted(...)
PhpSite_getPermitted(PhpSite self) -> std::string

PhpSite_getProhibited(...)
PhpSite_getProhibited(PhpSite self) -> std::string

PhpSite_getProjCoords(...)
PhpSite_getProjCoords(PhpSite self) -> SwigVectorDoubleVector

PhpSite_getProjectedOnly(...)
PhpSite_getProjectedOnly(PhpSite self) -> bool

PhpSite_getRad(...)
PhpSite_getRad(PhpSite self) -> double

PhpSite_getSiteDescription(...)
PhpSite_getSiteDescription(PhpSite self) -> std::string

PhpSite_getSiteName(...)
PhpSite_getSiteName(PhpSite self, int offset=1) -> std::string

PhpSite_getSiteNumber(...)
PhpSite_getSiteNumber(PhpSite self) -> size_t

PhpSite_getSiteSimilarity(...)
PhpSite_getSiteSimilarity(PhpSite self) -> int

PhpSite_getSiteStatus(...)
PhpSite_getSiteStatus(PhpSite self) -> int

PhpSite_getSiteType(...)
PhpSite_getSiteType(PhpSite self) -> std::string

PhpSite_getSiteTypeChar(...)
PhpSite_getSiteTypeChar(PhpSite self) -> char

PhpSite_getTol(...)
PhpSite_getTol(PhpSite self) -> double

PhpSite_getXCoord(...)
PhpSite_getXCoord(PhpSite self) -> double

PhpSite_getXP(...)
PhpSite_getXP(PhpSite self) -> double

PhpSite_getYCoord(...)
PhpSite_getYCoord(PhpSite self) -> double

PhpSite_getZCoord(...)
PhpSite_getZCoord(PhpSite self) -> double

PhpSite_hasXP(...)
PhpSite_hasXP(PhpSite self) -> bool

PhpSite_setCoordinates(...)
PhpSite_setCoordinates(PhpSite self, double a_x, double a_y, double a_z)

PhpSite_setDefaults(...)
PhpSite_setDefaults(PhpSite self)

PhpSite_setFragType(...)
PhpSite_setFragType(PhpSite self, std::string const & fragType)

PhpSite_setMaskValue(...)
PhpSite_setMaskValue(PhpSite self, int mask)

PhpSite_setPermitted(...)
PhpSite_setPermitted(PhpSite self, std::string const & permitted)

PhpSite_setProhibited(...)
PhpSite_setProhibited(PhpSite self, std::string const & prohibited)

PhpSite_setProjCoords(...)
PhpSite_setProjCoords(PhpSite self, SwigVectorDoubleVector projCoords)

PhpSite_setProjectedOnly(...)
PhpSite_setProjectedOnly(PhpSite self, bool const a_status)

PhpSite_setRad(...)
PhpSite_setRad(PhpSite self, double rad)

PhpSite_setSiteNumber(...)
PhpSite_setSiteNumber(PhpSite self, size_t const a_number)

PhpSite_setSiteSimilarity(...)
PhpSite_setSiteSimilarity(PhpSite self, int const a_type)

PhpSite_setSiteStatusOff(...)
PhpSite_setSiteStatusOff(PhpSite self)

PhpSite_setSiteStatusOn(...)
PhpSite_setSiteStatusOn(PhpSite self)

PhpSite_setSiteType(...)
PhpSite_setSiteType(PhpSite self, std::string const & a_type)

PhpSite_setSiteTypeChar(...)
PhpSite_setSiteTypeChar(PhpSite self, char const a_char)

PhpSite_setStatus(...)
PhpSite_setStatus(PhpSite self, int a_status)

PhpSite_setTol(...)
PhpSite_setTol(PhpSite self, double tol)

PhpSite_setXCoord(...)
PhpSite_setXCoord(PhpSite self, double a_x)

PhpSite_setXP(...)
PhpSite_setXP(PhpSite self, double xp, bool defined=True)

PhpSite_setYCoord(...)
PhpSite_setYCoord(PhpSite self, double a_y)

PhpSite_setZCoord(...)
PhpSite_setZCoord(PhpSite self, double a_z)

PhpSite_swiginit(...)

PhpSite_swigregister(...)

PhpVolCoords_swiginit(...)

PhpVolCoords_swigregister(...)

PhpVolCoords_x_get(...)
PhpVolCoords_x_get(PhpVolCoords self) -> double

PhpVolCoords_x_set(...)
PhpVolCoords_x_set(PhpVolCoords self, double x)

PhpVolCoords_y_get(...)
PhpVolCoords_y_get(PhpVolCoords self) -> double

PhpVolCoords_y_set(...)
PhpVolCoords_y_set(PhpVolCoords self, double y)

PhpVolCoords_z_get(...)
PhpVolCoords_z_get(PhpVolCoords self) -> double

PhpVolCoords_z_set(...)
PhpVolCoords_z_set(PhpVolCoords self, double z)

SWIG_PyInstanceMethod_New(...)

SwigDoubleVector___bool__(...)
SwigDoubleVector___bool__(SwigDoubleVector self) -> bool

SwigDoubleVector___delitem__(...)
__delitem__(std::vector< double >::difference_type i) SwigDoubleVector___delitem__(SwigDoubleVector self, PySliceObject * slice)

SwigDoubleVector___delslice__(...)
SwigDoubleVector___delslice__(SwigDoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)

SwigDoubleVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigDoubleVector SwigDoubleVector___getitem__(SwigDoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &

SwigDoubleVector___getslice__(...)
SwigDoubleVector___getslice__(SwigDoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> SwigDoubleVector

SwigDoubleVector___len__(...)
SwigDoubleVector___len__(SwigDoubleVector self) -> std::vector< double >::size_type

SwigDoubleVector___nonzero__(...)
SwigDoubleVector___nonzero__(SwigDoubleVector self) -> bool

SwigDoubleVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigDoubleVector v) __setitem__(PySliceObject * slice) SwigDoubleVector___setitem__(SwigDoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)

SwigDoubleVector___setslice__(...)
__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j) SwigDoubleVector___setslice__(SwigDoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, SwigDoubleVector v)

SwigDoubleVector_append(...)
SwigDoubleVector_append(SwigDoubleVector self, std::vector< double >::value_type const & x)

SwigDoubleVector_assign(...)
SwigDoubleVector_assign(SwigDoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

SwigDoubleVector_back(...)
SwigDoubleVector_back(SwigDoubleVector self) -> std::vector< double >::value_type const &

SwigDoubleVector_begin(...)
SwigDoubleVector_begin(SwigDoubleVector self) -> std::vector< double >::iterator

SwigDoubleVector_capacity(...)
SwigDoubleVector_capacity(SwigDoubleVector self) -> std::vector< double >::size_type

SwigDoubleVector_clear(...)
SwigDoubleVector_clear(SwigDoubleVector self)

SwigDoubleVector_empty(...)
SwigDoubleVector_empty(SwigDoubleVector self) -> bool

SwigDoubleVector_end(...)
SwigDoubleVector_end(SwigDoubleVector self) -> std::vector< double >::iterator

SwigDoubleVector_erase(...)
erase(std::vector< double >::iterator pos) -> std::vector< double >::iterator SwigDoubleVector_erase(SwigDoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator

SwigDoubleVector_front(...)
SwigDoubleVector_front(SwigDoubleVector self) -> std::vector< double >::value_type const &

SwigDoubleVector_get_allocator(...)
SwigDoubleVector_get_allocator(SwigDoubleVector self) -> std::vector< double >::allocator_type

SwigDoubleVector_insert(...)
insert(std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator SwigDoubleVector_insert(SwigDoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)

SwigDoubleVector_iterator(...)
SwigDoubleVector_iterator(SwigDoubleVector self) -> SwigPyIterator

SwigDoubleVector_pop(...)
SwigDoubleVector_pop(SwigDoubleVector self) -> std::vector< double >::value_type

SwigDoubleVector_pop_back(...)
SwigDoubleVector_pop_back(SwigDoubleVector self)

SwigDoubleVector_push_back(...)
SwigDoubleVector_push_back(SwigDoubleVector self, std::vector< double >::value_type const & x)

SwigDoubleVector_rbegin(...)
SwigDoubleVector_rbegin(SwigDoubleVector self) -> std::vector< double >::reverse_iterator

SwigDoubleVector_rend(...)
SwigDoubleVector_rend(SwigDoubleVector self) -> std::vector< double >::reverse_iterator

SwigDoubleVector_reserve(...)
SwigDoubleVector_reserve(SwigDoubleVector self, std::vector< double >::size_type n)

SwigDoubleVector_resize(...)
resize(std::vector< double >::size_type new_size) SwigDoubleVector_resize(SwigDoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)

SwigDoubleVector_size(...)
SwigDoubleVector_size(SwigDoubleVector self) -> std::vector< double >::size_type

SwigDoubleVector_swap(...)
SwigDoubleVector_swap(SwigDoubleVector self, SwigDoubleVector v)

SwigDoubleVector_swiginit(...)

SwigDoubleVector_swigregister(...)

SwigIntVector___bool__(...)
SwigIntVector___bool__(SwigIntVector self) -> bool

SwigIntVector___delitem__(...)
__delitem__(std::vector< int >::difference_type i) SwigIntVector___delitem__(SwigIntVector self, PySliceObject * slice)

SwigIntVector___delslice__(...)
SwigIntVector___delslice__(SwigIntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)

SwigIntVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigIntVector SwigIntVector___getitem__(SwigIntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &

SwigIntVector___getslice__(...)
SwigIntVector___getslice__(SwigIntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> SwigIntVector

SwigIntVector___len__(...)
SwigIntVector___len__(SwigIntVector self) -> std::vector< int >::size_type

SwigIntVector___nonzero__(...)
SwigIntVector___nonzero__(SwigIntVector self) -> bool

SwigIntVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigIntVector v) __setitem__(PySliceObject * slice) SwigIntVector___setitem__(SwigIntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)

SwigIntVector___setslice__(...)
__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j) SwigIntVector___setslice__(SwigIntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, SwigIntVector v)

SwigIntVector_append(...)
SwigIntVector_append(SwigIntVector self, std::vector< int >::value_type const & x)

SwigIntVector_assign(...)
SwigIntVector_assign(SwigIntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

SwigIntVector_back(...)
SwigIntVector_back(SwigIntVector self) -> std::vector< int >::value_type const &

SwigIntVector_begin(...)
SwigIntVector_begin(SwigIntVector self) -> std::vector< int >::iterator

SwigIntVector_capacity(...)
SwigIntVector_capacity(SwigIntVector self) -> std::vector< int >::size_type

SwigIntVector_clear(...)
SwigIntVector_clear(SwigIntVector self)

SwigIntVector_empty(...)
SwigIntVector_empty(SwigIntVector self) -> bool

SwigIntVector_end(...)
SwigIntVector_end(SwigIntVector self) -> std::vector< int >::iterator

SwigIntVector_erase(...)
erase(std::vector< int >::iterator pos) -> std::vector< int >::iterator SwigIntVector_erase(SwigIntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator

SwigIntVector_front(...)
SwigIntVector_front(SwigIntVector self) -> std::vector< int >::value_type const &

SwigIntVector_get_allocator(...)
SwigIntVector_get_allocator(SwigIntVector self) -> std::vector< int >::allocator_type

SwigIntVector_insert(...)
insert(std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator SwigIntVector_insert(SwigIntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)

SwigIntVector_iterator(...)
SwigIntVector_iterator(SwigIntVector self) -> SwigPyIterator

SwigIntVector_pop(...)
SwigIntVector_pop(SwigIntVector self) -> std::vector< int >::value_type

SwigIntVector_pop_back(...)
SwigIntVector_pop_back(SwigIntVector self)

SwigIntVector_push_back(...)
SwigIntVector_push_back(SwigIntVector self, std::vector< int >::value_type const & x)

SwigIntVector_rbegin(...)
SwigIntVector_rbegin(SwigIntVector self) -> std::vector< int >::reverse_iterator

SwigIntVector_rend(...)
SwigIntVector_rend(SwigIntVector self) -> std::vector< int >::reverse_iterator

SwigIntVector_reserve(...)
SwigIntVector_reserve(SwigIntVector self, std::vector< int >::size_type n)

SwigIntVector_resize(...)
resize(std::vector< int >::size_type new_size) SwigIntVector_resize(SwigIntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)

SwigIntVector_size(...)
SwigIntVector_size(SwigIntVector self) -> std::vector< int >::size_type

SwigIntVector_swap(...)
SwigIntVector_swap(SwigIntVector self, SwigIntVector v)

SwigIntVector_swiginit(...)

SwigIntVector_swigregister(...)

SwigPhpFpTypeVector___bool__(...)
SwigPhpFpTypeVector___bool__(SwigPhpFpTypeVector self) -> bool

SwigPhpFpTypeVector___delitem__(...)
__delitem__(std::vector< enum PhpFpType >::difference_type i) SwigPhpFpTypeVector___delitem__(SwigPhpFpTypeVector self, PySliceObject * slice)

SwigPhpFpTypeVector___delslice__(...)
SwigPhpFpTypeVector___delslice__(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::difference_type i, std::vector< enum PhpFpType >::difference_type j)

SwigPhpFpTypeVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigPhpFpTypeVector SwigPhpFpTypeVector___getitem__(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::difference_type i) -> std::vector< enum PhpFpType >::value_type const &

SwigPhpFpTypeVector___getslice__(...)
SwigPhpFpTypeVector___getslice__(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::difference_type i, std::vector< enum PhpFpType >::difference_type j) -> SwigPhpFpTypeVector

SwigPhpFpTypeVector___len__(...)
SwigPhpFpTypeVector___len__(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::size_type

SwigPhpFpTypeVector___nonzero__(...)
SwigPhpFpTypeVector___nonzero__(SwigPhpFpTypeVector self) -> bool

SwigPhpFpTypeVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigPhpFpTypeVector v) __setitem__(PySliceObject * slice) SwigPhpFpTypeVector___setitem__(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::difference_type i, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector___setslice__(...)
__setslice__(std::vector< enum PhpFpType >::difference_type i, std::vector< enum PhpFpType >::difference_type j) SwigPhpFpTypeVector___setslice__(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::difference_type i, std::vector< enum PhpFpType >::difference_type j, SwigPhpFpTypeVector v)

SwigPhpFpTypeVector_append(...)
SwigPhpFpTypeVector_append(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector_assign(...)
SwigPhpFpTypeVector_assign(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::size_type n, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector_back(...)
SwigPhpFpTypeVector_back(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::value_type const &

SwigPhpFpTypeVector_begin(...)
SwigPhpFpTypeVector_begin(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::iterator

SwigPhpFpTypeVector_capacity(...)
SwigPhpFpTypeVector_capacity(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::size_type

SwigPhpFpTypeVector_clear(...)
SwigPhpFpTypeVector_clear(SwigPhpFpTypeVector self)

SwigPhpFpTypeVector_empty(...)
SwigPhpFpTypeVector_empty(SwigPhpFpTypeVector self) -> bool

SwigPhpFpTypeVector_end(...)
SwigPhpFpTypeVector_end(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::iterator

SwigPhpFpTypeVector_erase(...)
erase(std::vector< enum PhpFpType >::iterator pos) -> std::vector< enum PhpFpType >::iterator SwigPhpFpTypeVector_erase(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::iterator first, std::vector< enum PhpFpType >::iterator last) -> std::vector< enum PhpFpType >::iterator

SwigPhpFpTypeVector_front(...)
SwigPhpFpTypeVector_front(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::value_type const &

SwigPhpFpTypeVector_get_allocator(...)
SwigPhpFpTypeVector_get_allocator(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::allocator_type

SwigPhpFpTypeVector_insert(...)
insert(std::vector< enum PhpFpType >::iterator pos, std::vector< enum PhpFpType >::value_type const & x) -> std::vector< enum PhpFpType >::iterator SwigPhpFpTypeVector_insert(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::iterator pos, std::vector< enum PhpFpType >::size_type n, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector_iterator(...)
SwigPhpFpTypeVector_iterator(SwigPhpFpTypeVector self) -> SwigPyIterator

SwigPhpFpTypeVector_pop(...)
SwigPhpFpTypeVector_pop(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::value_type

SwigPhpFpTypeVector_pop_back(...)
SwigPhpFpTypeVector_pop_back(SwigPhpFpTypeVector self)

SwigPhpFpTypeVector_push_back(...)
SwigPhpFpTypeVector_push_back(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector_rbegin(...)
SwigPhpFpTypeVector_rbegin(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::reverse_iterator

SwigPhpFpTypeVector_rend(...)
SwigPhpFpTypeVector_rend(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::reverse_iterator

SwigPhpFpTypeVector_reserve(...)
SwigPhpFpTypeVector_reserve(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::size_type n)

SwigPhpFpTypeVector_resize(...)
resize(std::vector< enum PhpFpType >::size_type new_size) SwigPhpFpTypeVector_resize(SwigPhpFpTypeVector self, std::vector< enum PhpFpType >::size_type new_size, std::vector< enum PhpFpType >::value_type const & x)

SwigPhpFpTypeVector_size(...)
SwigPhpFpTypeVector_size(SwigPhpFpTypeVector self) -> std::vector< enum PhpFpType >::size_type

SwigPhpFpTypeVector_swap(...)
SwigPhpFpTypeVector_swap(SwigPhpFpTypeVector self, SwigPhpFpTypeVector v)

SwigPhpFpTypeVector_swiginit(...)

SwigPhpFpTypeVector_swigregister(...)

SwigPyIterator___add__(...)
SwigPyIterator___add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

SwigPyIterator___eq__(...)
SwigPyIterator___eq__(SwigPyIterator self, SwigPyIterator x) -> bool

SwigPyIterator___iadd__(...)
SwigPyIterator___iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

SwigPyIterator___isub__(...)
SwigPyIterator___isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

SwigPyIterator___ne__(...)
SwigPyIterator___ne__(SwigPyIterator self, SwigPyIterator x) -> bool

SwigPyIterator___next__(...)
SwigPyIterator___next__(SwigPyIterator self) -> PyObject *

SwigPyIterator___sub__(...)
__sub__(ptrdiff_t n) -> SwigPyIterator SwigPyIterator___sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

SwigPyIterator_advance(...)
SwigPyIterator_advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator

SwigPyIterator_copy(...)
SwigPyIterator_copy(SwigPyIterator self) -> SwigPyIterator

SwigPyIterator_decr(...)
SwigPyIterator_decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

SwigPyIterator_distance(...)
SwigPyIterator_distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t

SwigPyIterator_equal(...)
SwigPyIterator_equal(SwigPyIterator self, SwigPyIterator x) -> bool

SwigPyIterator_incr(...)
SwigPyIterator_incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator

SwigPyIterator_next(...)
SwigPyIterator_next(SwigPyIterator self) -> PyObject *

SwigPyIterator_previous(...)
SwigPyIterator_previous(SwigPyIterator self) -> PyObject *

SwigPyIterator_swigregister(...)

SwigPyIterator_value(...)
SwigPyIterator_value(SwigPyIterator self) -> PyObject *

SwigSizetVector___bool__(...)
SwigSizetVector___bool__(SwigSizetVector self) -> bool

SwigSizetVector___delitem__(...)
__delitem__(std::vector< size_t >::difference_type i) SwigSizetVector___delitem__(SwigSizetVector self, PySliceObject * slice)

SwigSizetVector___delslice__(...)
SwigSizetVector___delslice__(SwigSizetVector self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)

SwigSizetVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigSizetVector SwigSizetVector___getitem__(SwigSizetVector self, std::vector< size_t >::difference_type i) -> std::vector< size_t >::value_type const &

SwigSizetVector___getslice__(...)
SwigSizetVector___getslice__(SwigSizetVector self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) -> SwigSizetVector

SwigSizetVector___len__(...)
SwigSizetVector___len__(SwigSizetVector self) -> std::vector< size_t >::size_type

SwigSizetVector___nonzero__(...)
SwigSizetVector___nonzero__(SwigSizetVector self) -> bool

SwigSizetVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigSizetVector v) __setitem__(PySliceObject * slice) SwigSizetVector___setitem__(SwigSizetVector self, std::vector< size_t >::difference_type i, std::vector< size_t >::value_type const & x)

SwigSizetVector___setslice__(...)
__setslice__(std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) SwigSizetVector___setslice__(SwigSizetVector self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, SwigSizetVector v)

SwigSizetVector_append(...)
SwigSizetVector_append(SwigSizetVector self, std::vector< size_t >::value_type const & x)

SwigSizetVector_assign(...)
SwigSizetVector_assign(SwigSizetVector self, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)

SwigSizetVector_back(...)
SwigSizetVector_back(SwigSizetVector self) -> std::vector< size_t >::value_type const &

SwigSizetVector_begin(...)
SwigSizetVector_begin(SwigSizetVector self) -> std::vector< size_t >::iterator

SwigSizetVector_capacity(...)
SwigSizetVector_capacity(SwigSizetVector self) -> std::vector< size_t >::size_type

SwigSizetVector_clear(...)
SwigSizetVector_clear(SwigSizetVector self)

SwigSizetVector_empty(...)
SwigSizetVector_empty(SwigSizetVector self) -> bool

SwigSizetVector_end(...)
SwigSizetVector_end(SwigSizetVector self) -> std::vector< size_t >::iterator

SwigSizetVector_erase(...)
erase(std::vector< size_t >::iterator pos) -> std::vector< size_t >::iterator SwigSizetVector_erase(SwigSizetVector self, std::vector< size_t >::iterator first, std::vector< size_t >::iterator last) -> std::vector< size_t >::iterator

SwigSizetVector_front(...)
SwigSizetVector_front(SwigSizetVector self) -> std::vector< size_t >::value_type const &

SwigSizetVector_get_allocator(...)
SwigSizetVector_get_allocator(SwigSizetVector self) -> std::vector< size_t >::allocator_type

SwigSizetVector_insert(...)
insert(std::vector< size_t >::iterator pos, std::vector< size_t >::value_type const & x) -> std::vector< size_t >::iterator SwigSizetVector_insert(SwigSizetVector self, std::vector< size_t >::iterator pos, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)

SwigSizetVector_iterator(...)
SwigSizetVector_iterator(SwigSizetVector self) -> SwigPyIterator

SwigSizetVector_pop(...)
SwigSizetVector_pop(SwigSizetVector self) -> std::vector< size_t >::value_type

SwigSizetVector_pop_back(...)
SwigSizetVector_pop_back(SwigSizetVector self)

SwigSizetVector_push_back(...)
SwigSizetVector_push_back(SwigSizetVector self, std::vector< size_t >::value_type const & x)

SwigSizetVector_rbegin(...)
SwigSizetVector_rbegin(SwigSizetVector self) -> std::vector< size_t >::reverse_iterator

SwigSizetVector_rend(...)
SwigSizetVector_rend(SwigSizetVector self) -> std::vector< size_t >::reverse_iterator

SwigSizetVector_reserve(...)
SwigSizetVector_reserve(SwigSizetVector self, std::vector< size_t >::size_type n)

SwigSizetVector_resize(...)
resize(std::vector< size_t >::size_type new_size) SwigSizetVector_resize(SwigSizetVector self, std::vector< size_t >::size_type new_size, std::vector< size_t >::value_type const & x)

SwigSizetVector_size(...)
SwigSizetVector_size(SwigSizetVector self) -> std::vector< size_t >::size_type

SwigSizetVector_swap(...)
SwigSizetVector_swap(SwigSizetVector self, SwigSizetVector v)

SwigSizetVector_swiginit(...)

SwigSizetVector_swigregister(...)

SwigStringVector___bool__(...)
SwigStringVector___bool__(SwigStringVector self) -> bool

SwigStringVector___delitem__(...)
__delitem__(std::vector< std::string >::difference_type i) SwigStringVector___delitem__(SwigStringVector self, PySliceObject * slice)

SwigStringVector___delslice__(...)
SwigStringVector___delslice__(SwigStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)

SwigStringVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigStringVector SwigStringVector___getitem__(SwigStringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &

SwigStringVector___getslice__(...)
SwigStringVector___getslice__(SwigStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> SwigStringVector

SwigStringVector___len__(...)
SwigStringVector___len__(SwigStringVector self) -> std::vector< std::string >::size_type

SwigStringVector___nonzero__(...)
SwigStringVector___nonzero__(SwigStringVector self) -> bool

SwigStringVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigStringVector v) __setitem__(PySliceObject * slice) SwigStringVector___setitem__(SwigStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)

SwigStringVector___setslice__(...)
__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) SwigStringVector___setslice__(SwigStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, SwigStringVector v)

SwigStringVector_append(...)
SwigStringVector_append(SwigStringVector self, std::vector< std::string >::value_type const & x)

SwigStringVector_assign(...)
SwigStringVector_assign(SwigStringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

SwigStringVector_back(...)
SwigStringVector_back(SwigStringVector self) -> std::vector< std::string >::value_type const &

SwigStringVector_begin(...)
SwigStringVector_begin(SwigStringVector self) -> std::vector< std::string >::iterator

SwigStringVector_capacity(...)
SwigStringVector_capacity(SwigStringVector self) -> std::vector< std::string >::size_type

SwigStringVector_clear(...)
SwigStringVector_clear(SwigStringVector self)

SwigStringVector_empty(...)
SwigStringVector_empty(SwigStringVector self) -> bool

SwigStringVector_end(...)
SwigStringVector_end(SwigStringVector self) -> std::vector< std::string >::iterator

SwigStringVector_erase(...)
erase(std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator SwigStringVector_erase(SwigStringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator

SwigStringVector_front(...)
SwigStringVector_front(SwigStringVector self) -> std::vector< std::string >::value_type const &

SwigStringVector_get_allocator(...)
SwigStringVector_get_allocator(SwigStringVector self) -> std::vector< std::string >::allocator_type

SwigStringVector_insert(...)
insert(std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator SwigStringVector_insert(SwigStringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)

SwigStringVector_iterator(...)
SwigStringVector_iterator(SwigStringVector self) -> SwigPyIterator

SwigStringVector_pop(...)
SwigStringVector_pop(SwigStringVector self) -> std::vector< std::string >::value_type

SwigStringVector_pop_back(...)
SwigStringVector_pop_back(SwigStringVector self)

SwigStringVector_push_back(...)
SwigStringVector_push_back(SwigStringVector self, std::vector< std::string >::value_type const & x)

SwigStringVector_rbegin(...)
SwigStringVector_rbegin(SwigStringVector self) -> std::vector< std::string >::reverse_iterator

SwigStringVector_rend(...)
SwigStringVector_rend(SwigStringVector self) -> std::vector< std::string >::reverse_iterator

SwigStringVector_reserve(...)
SwigStringVector_reserve(SwigStringVector self, std::vector< std::string >::size_type n)

SwigStringVector_resize(...)
resize(std::vector< std::string >::size_type new_size) SwigStringVector_resize(SwigStringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)

SwigStringVector_size(...)
SwigStringVector_size(SwigStringVector self) -> std::vector< std::string >::size_type

SwigStringVector_swap(...)
SwigStringVector_swap(SwigStringVector self, SwigStringVector v)

SwigStringVector_swiginit(...)

SwigStringVector_swigregister(...)

SwigUnsignedIntVector___bool__(...)
SwigUnsignedIntVector___bool__(SwigUnsignedIntVector self) -> bool

SwigUnsignedIntVector___delitem__(...)
__delitem__(std::vector< unsigned int >::difference_type i) SwigUnsignedIntVector___delitem__(SwigUnsignedIntVector self, PySliceObject * slice)

SwigUnsignedIntVector___delslice__(...)
SwigUnsignedIntVector___delslice__(SwigUnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)

SwigUnsignedIntVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigUnsignedIntVector SwigUnsignedIntVector___getitem__(SwigUnsignedIntVector self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &

SwigUnsignedIntVector___getslice__(...)
SwigUnsignedIntVector___getslice__(SwigUnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> SwigUnsignedIntVector

SwigUnsignedIntVector___len__(...)
SwigUnsignedIntVector___len__(SwigUnsignedIntVector self) -> std::vector< unsigned int >::size_type

SwigUnsignedIntVector___nonzero__(...)
SwigUnsignedIntVector___nonzero__(SwigUnsignedIntVector self) -> bool

SwigUnsignedIntVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigUnsignedIntVector v) __setitem__(PySliceObject * slice) SwigUnsignedIntVector___setitem__(SwigUnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector___setslice__(...)
__setslice__(std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) SwigUnsignedIntVector___setslice__(SwigUnsignedIntVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, SwigUnsignedIntVector v)

SwigUnsignedIntVector_append(...)
SwigUnsignedIntVector_append(SwigUnsignedIntVector self, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector_assign(...)
SwigUnsignedIntVector_assign(SwigUnsignedIntVector self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector_back(...)
SwigUnsignedIntVector_back(SwigUnsignedIntVector self) -> std::vector< unsigned int >::value_type const &

SwigUnsignedIntVector_begin(...)
SwigUnsignedIntVector_begin(SwigUnsignedIntVector self) -> std::vector< unsigned int >::iterator

SwigUnsignedIntVector_capacity(...)
SwigUnsignedIntVector_capacity(SwigUnsignedIntVector self) -> std::vector< unsigned int >::size_type

SwigUnsignedIntVector_clear(...)
SwigUnsignedIntVector_clear(SwigUnsignedIntVector self)

SwigUnsignedIntVector_empty(...)
SwigUnsignedIntVector_empty(SwigUnsignedIntVector self) -> bool

SwigUnsignedIntVector_end(...)
SwigUnsignedIntVector_end(SwigUnsignedIntVector self) -> std::vector< unsigned int >::iterator

SwigUnsignedIntVector_erase(...)
erase(std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator SwigUnsignedIntVector_erase(SwigUnsignedIntVector self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator

SwigUnsignedIntVector_front(...)
SwigUnsignedIntVector_front(SwigUnsignedIntVector self) -> std::vector< unsigned int >::value_type const &

SwigUnsignedIntVector_get_allocator(...)
SwigUnsignedIntVector_get_allocator(SwigUnsignedIntVector self) -> std::vector< unsigned int >::allocator_type

SwigUnsignedIntVector_insert(...)
insert(std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator SwigUnsignedIntVector_insert(SwigUnsignedIntVector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector_iterator(...)
SwigUnsignedIntVector_iterator(SwigUnsignedIntVector self) -> SwigPyIterator

SwigUnsignedIntVector_pop(...)
SwigUnsignedIntVector_pop(SwigUnsignedIntVector self) -> std::vector< unsigned int >::value_type

SwigUnsignedIntVector_pop_back(...)
SwigUnsignedIntVector_pop_back(SwigUnsignedIntVector self)

SwigUnsignedIntVector_push_back(...)
SwigUnsignedIntVector_push_back(SwigUnsignedIntVector self, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector_rbegin(...)
SwigUnsignedIntVector_rbegin(SwigUnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator

SwigUnsignedIntVector_rend(...)
SwigUnsignedIntVector_rend(SwigUnsignedIntVector self) -> std::vector< unsigned int >::reverse_iterator

SwigUnsignedIntVector_reserve(...)
SwigUnsignedIntVector_reserve(SwigUnsignedIntVector self, std::vector< unsigned int >::size_type n)

SwigUnsignedIntVector_resize(...)
resize(std::vector< unsigned int >::size_type new_size) SwigUnsignedIntVector_resize(SwigUnsignedIntVector self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)

SwigUnsignedIntVector_size(...)
SwigUnsignedIntVector_size(SwigUnsignedIntVector self) -> std::vector< unsigned int >::size_type

SwigUnsignedIntVector_swap(...)
SwigUnsignedIntVector_swap(SwigUnsignedIntVector self, SwigUnsignedIntVector v)

SwigUnsignedIntVector_swiginit(...)

SwigUnsignedIntVector_swigregister(...)

SwigVectorDoubleVector___bool__(...)
SwigVectorDoubleVector___bool__(SwigVectorDoubleVector self) -> bool

SwigVectorDoubleVector___delitem__(...)
__delitem__(std::vector< std::vector< double > >::difference_type i) SwigVectorDoubleVector___delitem__(SwigVectorDoubleVector self, PySliceObject * slice)

SwigVectorDoubleVector___delslice__(...)
SwigVectorDoubleVector___delslice__(SwigVectorDoubleVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)

SwigVectorDoubleVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorDoubleVector SwigVectorDoubleVector___getitem__(SwigVectorDoubleVector self, std::vector< std::vector< double > >::difference_type i) -> SwigDoubleVector

SwigVectorDoubleVector___getslice__(...)
SwigVectorDoubleVector___getslice__(SwigVectorDoubleVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> SwigVectorDoubleVector

SwigVectorDoubleVector___len__(...)
SwigVectorDoubleVector___len__(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::size_type

SwigVectorDoubleVector___nonzero__(...)
SwigVectorDoubleVector___nonzero__(SwigVectorDoubleVector self) -> bool

SwigVectorDoubleVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorDoubleVector v) __setitem__(PySliceObject * slice) SwigVectorDoubleVector___setitem__(SwigVectorDoubleVector self, std::vector< std::vector< double > >::difference_type i, SwigDoubleVector x)

SwigVectorDoubleVector___setslice__(...)
__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) SwigVectorDoubleVector___setslice__(SwigVectorDoubleVector self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, SwigVectorDoubleVector v)

SwigVectorDoubleVector_append(...)
SwigVectorDoubleVector_append(SwigVectorDoubleVector self, SwigDoubleVector x)

SwigVectorDoubleVector_assign(...)
SwigVectorDoubleVector_assign(SwigVectorDoubleVector self, std::vector< std::vector< double > >::size_type n, SwigDoubleVector x)

SwigVectorDoubleVector_back(...)
SwigVectorDoubleVector_back(SwigVectorDoubleVector self) -> SwigDoubleVector

SwigVectorDoubleVector_begin(...)
SwigVectorDoubleVector_begin(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::iterator

SwigVectorDoubleVector_capacity(...)
SwigVectorDoubleVector_capacity(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::size_type

SwigVectorDoubleVector_clear(...)
SwigVectorDoubleVector_clear(SwigVectorDoubleVector self)

SwigVectorDoubleVector_empty(...)
SwigVectorDoubleVector_empty(SwigVectorDoubleVector self) -> bool

SwigVectorDoubleVector_end(...)
SwigVectorDoubleVector_end(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::iterator

SwigVectorDoubleVector_erase(...)
erase(std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator SwigVectorDoubleVector_erase(SwigVectorDoubleVector self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator

SwigVectorDoubleVector_front(...)
SwigVectorDoubleVector_front(SwigVectorDoubleVector self) -> SwigDoubleVector

SwigVectorDoubleVector_get_allocator(...)
SwigVectorDoubleVector_get_allocator(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::allocator_type

SwigVectorDoubleVector_insert(...)
insert(std::vector< std::vector< double > >::iterator pos, SwigDoubleVector x) -> std::vector< std::vector< double > >::iterator SwigVectorDoubleVector_insert(SwigVectorDoubleVector self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, SwigDoubleVector x)

SwigVectorDoubleVector_iterator(...)
SwigVectorDoubleVector_iterator(SwigVectorDoubleVector self) -> SwigPyIterator

SwigVectorDoubleVector_pop(...)
SwigVectorDoubleVector_pop(SwigVectorDoubleVector self) -> SwigDoubleVector

SwigVectorDoubleVector_pop_back(...)
SwigVectorDoubleVector_pop_back(SwigVectorDoubleVector self)

SwigVectorDoubleVector_push_back(...)
SwigVectorDoubleVector_push_back(SwigVectorDoubleVector self, SwigDoubleVector x)

SwigVectorDoubleVector_rbegin(...)
SwigVectorDoubleVector_rbegin(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::reverse_iterator

SwigVectorDoubleVector_rend(...)
SwigVectorDoubleVector_rend(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::reverse_iterator

SwigVectorDoubleVector_reserve(...)
SwigVectorDoubleVector_reserve(SwigVectorDoubleVector self, std::vector< std::vector< double > >::size_type n)

SwigVectorDoubleVector_resize(...)
resize(std::vector< std::vector< double > >::size_type new_size) SwigVectorDoubleVector_resize(SwigVectorDoubleVector self, std::vector< std::vector< double > >::size_type new_size, SwigDoubleVector x)

SwigVectorDoubleVector_size(...)
SwigVectorDoubleVector_size(SwigVectorDoubleVector self) -> std::vector< std::vector< double > >::size_type

SwigVectorDoubleVector_swap(...)
SwigVectorDoubleVector_swap(SwigVectorDoubleVector self, SwigVectorDoubleVector v)

SwigVectorDoubleVector_swiginit(...)

SwigVectorDoubleVector_swigregister(...)

SwigVectorIntVector___bool__(...)
SwigVectorIntVector___bool__(SwigVectorIntVector self) -> bool

SwigVectorIntVector___delitem__(...)
__delitem__(std::vector< std::vector< int > >::difference_type i) SwigVectorIntVector___delitem__(SwigVectorIntVector self, PySliceObject * slice)

SwigVectorIntVector___delslice__(...)
SwigVectorIntVector___delslice__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j)

SwigVectorIntVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorIntVector SwigVectorIntVector___getitem__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i) -> SwigIntVector

SwigVectorIntVector___getslice__(...)
SwigVectorIntVector___getslice__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) -> SwigVectorIntVector

SwigVectorIntVector___len__(...)
SwigVectorIntVector___len__(SwigVectorIntVector self) -> std::vector< std::vector< int > >::size_type

SwigVectorIntVector___nonzero__(...)
SwigVectorIntVector___nonzero__(SwigVectorIntVector self) -> bool

SwigVectorIntVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorIntVector v) __setitem__(PySliceObject * slice) SwigVectorIntVector___setitem__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, SwigIntVector x)

SwigVectorIntVector___setslice__(...)
__setslice__(std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j) SwigVectorIntVector___setslice__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, SwigVectorIntVector v)

SwigVectorIntVector_append(...)
SwigVectorIntVector_append(SwigVectorIntVector self, SwigIntVector x)

SwigVectorIntVector_assign(...)
SwigVectorIntVector_assign(SwigVectorIntVector self, std::vector< std::vector< int > >::size_type n, SwigIntVector x)

SwigVectorIntVector_back(...)
SwigVectorIntVector_back(SwigVectorIntVector self) -> SwigIntVector

SwigVectorIntVector_begin(...)
SwigVectorIntVector_begin(SwigVectorIntVector self) -> std::vector< std::vector< int > >::iterator

SwigVectorIntVector_capacity(...)
SwigVectorIntVector_capacity(SwigVectorIntVector self) -> std::vector< std::vector< int > >::size_type

SwigVectorIntVector_clear(...)
SwigVectorIntVector_clear(SwigVectorIntVector self)

SwigVectorIntVector_empty(...)
SwigVectorIntVector_empty(SwigVectorIntVector self) -> bool

SwigVectorIntVector_end(...)
SwigVectorIntVector_end(SwigVectorIntVector self) -> std::vector< std::vector< int > >::iterator

SwigVectorIntVector_erase(...)
erase(std::vector< std::vector< int > >::iterator pos) -> std::vector< std::vector< int > >::iterator SwigVectorIntVector_erase(SwigVectorIntVector self, std::vector< std::vector< int > >::iterator first, std::vector< std::vector< int > >::iterator last) -> std::vector< std::vector< int > >::iterator

SwigVectorIntVector_front(...)
SwigVectorIntVector_front(SwigVectorIntVector self) -> SwigIntVector

SwigVectorIntVector_get_allocator(...)
SwigVectorIntVector_get_allocator(SwigVectorIntVector self) -> std::vector< std::vector< int > >::allocator_type

SwigVectorIntVector_insert(...)
insert(std::vector< std::vector< int > >::iterator pos, SwigIntVector x) -> std::vector< std::vector< int > >::iterator SwigVectorIntVector_insert(SwigVectorIntVector self, std::vector< std::vector< int > >::iterator pos, std::vector< std::vector< int > >::size_type n, SwigIntVector x)

SwigVectorIntVector_iterator(...)
SwigVectorIntVector_iterator(SwigVectorIntVector self) -> SwigPyIterator

SwigVectorIntVector_pop(...)
SwigVectorIntVector_pop(SwigVectorIntVector self) -> SwigIntVector

SwigVectorIntVector_pop_back(...)
SwigVectorIntVector_pop_back(SwigVectorIntVector self)

SwigVectorIntVector_push_back(...)
SwigVectorIntVector_push_back(SwigVectorIntVector self, SwigIntVector x)

SwigVectorIntVector_rbegin(...)
SwigVectorIntVector_rbegin(SwigVectorIntVector self) -> std::vector< std::vector< int > >::reverse_iterator

SwigVectorIntVector_rend(...)
SwigVectorIntVector_rend(SwigVectorIntVector self) -> std::vector< std::vector< int > >::reverse_iterator

SwigVectorIntVector_reserve(...)
SwigVectorIntVector_reserve(SwigVectorIntVector self, std::vector< std::vector< int > >::size_type n)

SwigVectorIntVector_resize(...)
resize(std::vector< std::vector< int > >::size_type new_size) SwigVectorIntVector_resize(SwigVectorIntVector self, std::vector< std::vector< int > >::size_type new_size, SwigIntVector x)

SwigVectorIntVector_size(...)
SwigVectorIntVector_size(SwigVectorIntVector self) -> std::vector< std::vector< int > >::size_type

SwigVectorIntVector_swap(...)
SwigVectorIntVector_swap(SwigVectorIntVector self, SwigVectorIntVector v)

SwigVectorIntVector_swiginit(...)

SwigVectorIntVector_swigregister(...)

SwigVectorPhpSitePhpSite___bool__(...)
SwigVectorPhpSitePhpSite___bool__(SwigVectorPhpSitePhpSite self) -> bool

SwigVectorPhpSitePhpSite___delitem__(...)
__delitem__(std::vector< std::pair< PhpSite,PhpSite > >::difference_type i) SwigVectorPhpSitePhpSite___delitem__(SwigVectorPhpSitePhpSite self, PySliceObject * slice)

SwigVectorPhpSitePhpSite___delslice__(...)
SwigVectorPhpSitePhpSite___delslice__(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::difference_type i, std::vector< std::pair< PhpSite,PhpSite > >::difference_type j)

SwigVectorPhpSitePhpSite___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorPhpSitePhpSite SwigVectorPhpSitePhpSite___getitem__(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::difference_type i) -> std::vector< std::pair< PhpSite,PhpSite > >::value_type const &

SwigVectorPhpSitePhpSite___getslice__(...)
SwigVectorPhpSitePhpSite___getslice__(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::difference_type i, std::vector< std::pair< PhpSite,PhpSite > >::difference_type j) -> SwigVectorPhpSitePhpSite

SwigVectorPhpSitePhpSite___len__(...)
SwigVectorPhpSitePhpSite___len__(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::size_type

SwigVectorPhpSitePhpSite___nonzero__(...)
SwigVectorPhpSitePhpSite___nonzero__(SwigVectorPhpSitePhpSite self) -> bool

SwigVectorPhpSitePhpSite___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorPhpSitePhpSite v) __setitem__(PySliceObject * slice) SwigVectorPhpSitePhpSite___setitem__(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::difference_type i, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite___setslice__(...)
__setslice__(std::vector< std::pair< PhpSite,PhpSite > >::difference_type i, std::vector< std::pair< PhpSite,PhpSite > >::difference_type j) SwigVectorPhpSitePhpSite___setslice__(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::difference_type i, std::vector< std::pair< PhpSite,PhpSite > >::difference_type j, SwigVectorPhpSitePhpSite v)

SwigVectorPhpSitePhpSite_append(...)
SwigVectorPhpSitePhpSite_append(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite_assign(...)
SwigVectorPhpSitePhpSite_assign(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::size_type n, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite_back(...)
SwigVectorPhpSitePhpSite_back(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::value_type const &

SwigVectorPhpSitePhpSite_begin(...)
SwigVectorPhpSitePhpSite_begin(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::iterator

SwigVectorPhpSitePhpSite_capacity(...)
SwigVectorPhpSitePhpSite_capacity(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::size_type

SwigVectorPhpSitePhpSite_clear(...)
SwigVectorPhpSitePhpSite_clear(SwigVectorPhpSitePhpSite self)

SwigVectorPhpSitePhpSite_empty(...)
SwigVectorPhpSitePhpSite_empty(SwigVectorPhpSitePhpSite self) -> bool

SwigVectorPhpSitePhpSite_end(...)
SwigVectorPhpSitePhpSite_end(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::iterator

SwigVectorPhpSitePhpSite_erase(...)
erase(std::vector< std::pair< PhpSite,PhpSite > >::iterator pos) -> std::vector< std::pair< PhpSite,PhpSite > >::iterator SwigVectorPhpSitePhpSite_erase(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::iterator first, std::vector< std::pair< PhpSite,PhpSite > >::iterator last) -> std::vector< std::pair< PhpSite,PhpSite > >::iterator

SwigVectorPhpSitePhpSite_front(...)
SwigVectorPhpSitePhpSite_front(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::value_type const &

SwigVectorPhpSitePhpSite_get_allocator(...)
SwigVectorPhpSitePhpSite_get_allocator(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::allocator_type

SwigVectorPhpSitePhpSite_insert(...)
insert(std::vector< std::pair< PhpSite,PhpSite > >::iterator pos, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x) -> std::vector< std::pair< PhpSite,PhpSite > >::iterator SwigVectorPhpSitePhpSite_insert(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::iterator pos, std::vector< std::pair< PhpSite,PhpSite > >::size_type n, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite_iterator(...)
SwigVectorPhpSitePhpSite_iterator(SwigVectorPhpSitePhpSite self) -> SwigPyIterator

SwigVectorPhpSitePhpSite_pop(...)
SwigVectorPhpSitePhpSite_pop(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::value_type

SwigVectorPhpSitePhpSite_pop_back(...)
SwigVectorPhpSitePhpSite_pop_back(SwigVectorPhpSitePhpSite self)

SwigVectorPhpSitePhpSite_push_back(...)
SwigVectorPhpSitePhpSite_push_back(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite_rbegin(...)
SwigVectorPhpSitePhpSite_rbegin(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::reverse_iterator

SwigVectorPhpSitePhpSite_rend(...)
SwigVectorPhpSitePhpSite_rend(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::reverse_iterator

SwigVectorPhpSitePhpSite_reserve(...)
SwigVectorPhpSitePhpSite_reserve(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::size_type n)

SwigVectorPhpSitePhpSite_resize(...)
resize(std::vector< std::pair< PhpSite,PhpSite > >::size_type new_size) SwigVectorPhpSitePhpSite_resize(SwigVectorPhpSitePhpSite self, std::vector< std::pair< PhpSite,PhpSite > >::size_type new_size, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & x)

SwigVectorPhpSitePhpSite_size(...)
SwigVectorPhpSitePhpSite_size(SwigVectorPhpSitePhpSite self) -> std::vector< std::pair< PhpSite,PhpSite > >::size_type

SwigVectorPhpSitePhpSite_swap(...)
SwigVectorPhpSitePhpSite_swap(SwigVectorPhpSitePhpSite self, SwigVectorPhpSitePhpSite v)

SwigVectorPhpSitePhpSite_swiginit(...)

SwigVectorPhpSitePhpSite_swigregister(...)

SwigVectorSizetVector___bool__(...)
SwigVectorSizetVector___bool__(SwigVectorSizetVector self) -> bool

SwigVectorSizetVector___delitem__(...)
__delitem__(std::vector< std::vector< size_t > >::difference_type i) SwigVectorSizetVector___delitem__(SwigVectorSizetVector self, PySliceObject * slice)

SwigVectorSizetVector___delslice__(...)
SwigVectorSizetVector___delslice__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, std::vector< std::vector< size_t > >::difference_type j)

SwigVectorSizetVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorSizetVector SwigVectorSizetVector___getitem__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i) -> SwigSizetVector

SwigVectorSizetVector___getslice__(...)
SwigVectorSizetVector___getslice__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, std::vector< std::vector< size_t > >::difference_type j) -> SwigVectorSizetVector

SwigVectorSizetVector___len__(...)
SwigVectorSizetVector___len__(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::size_type

SwigVectorSizetVector___nonzero__(...)
SwigVectorSizetVector___nonzero__(SwigVectorSizetVector self) -> bool

SwigVectorSizetVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorSizetVector v) __setitem__(PySliceObject * slice) SwigVectorSizetVector___setitem__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, SwigSizetVector x)

SwigVectorSizetVector___setslice__(...)
__setslice__(std::vector< std::vector< size_t > >::difference_type i, std::vector< std::vector< size_t > >::difference_type j) SwigVectorSizetVector___setslice__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, std::vector< std::vector< size_t > >::difference_type j, SwigVectorSizetVector v)

SwigVectorSizetVector_append(...)
SwigVectorSizetVector_append(SwigVectorSizetVector self, SwigSizetVector x)

SwigVectorSizetVector_assign(...)
SwigVectorSizetVector_assign(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::size_type n, SwigSizetVector x)

SwigVectorSizetVector_back(...)
SwigVectorSizetVector_back(SwigVectorSizetVector self) -> SwigSizetVector

SwigVectorSizetVector_begin(...)
SwigVectorSizetVector_begin(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::iterator

SwigVectorSizetVector_capacity(...)
SwigVectorSizetVector_capacity(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::size_type

SwigVectorSizetVector_clear(...)
SwigVectorSizetVector_clear(SwigVectorSizetVector self)

SwigVectorSizetVector_empty(...)
SwigVectorSizetVector_empty(SwigVectorSizetVector self) -> bool

SwigVectorSizetVector_end(...)
SwigVectorSizetVector_end(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::iterator

SwigVectorSizetVector_erase(...)
erase(std::vector< std::vector< size_t > >::iterator pos) -> std::vector< std::vector< size_t > >::iterator SwigVectorSizetVector_erase(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::iterator first, std::vector< std::vector< size_t > >::iterator last) -> std::vector< std::vector< size_t > >::iterator

SwigVectorSizetVector_front(...)
SwigVectorSizetVector_front(SwigVectorSizetVector self) -> SwigSizetVector

SwigVectorSizetVector_get_allocator(...)
SwigVectorSizetVector_get_allocator(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::allocator_type

SwigVectorSizetVector_insert(...)
insert(std::vector< std::vector< size_t > >::iterator pos, SwigSizetVector x) -> std::vector< std::vector< size_t > >::iterator SwigVectorSizetVector_insert(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::iterator pos, std::vector< std::vector< size_t > >::size_type n, SwigSizetVector x)

SwigVectorSizetVector_iterator(...)
SwigVectorSizetVector_iterator(SwigVectorSizetVector self) -> SwigPyIterator

SwigVectorSizetVector_pop(...)
SwigVectorSizetVector_pop(SwigVectorSizetVector self) -> SwigSizetVector

SwigVectorSizetVector_pop_back(...)
SwigVectorSizetVector_pop_back(SwigVectorSizetVector self)

SwigVectorSizetVector_push_back(...)
SwigVectorSizetVector_push_back(SwigVectorSizetVector self, SwigSizetVector x)

SwigVectorSizetVector_rbegin(...)
SwigVectorSizetVector_rbegin(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::reverse_iterator

SwigVectorSizetVector_rend(...)
SwigVectorSizetVector_rend(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::reverse_iterator

SwigVectorSizetVector_reserve(...)
SwigVectorSizetVector_reserve(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::size_type n)

SwigVectorSizetVector_resize(...)
resize(std::vector< std::vector< size_t > >::size_type new_size) SwigVectorSizetVector_resize(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::size_type new_size, SwigSizetVector x)

SwigVectorSizetVector_size(...)
SwigVectorSizetVector_size(SwigVectorSizetVector self) -> std::vector< std::vector< size_t > >::size_type

SwigVectorSizetVector_swap(...)
SwigVectorSizetVector_swap(SwigVectorSizetVector self, SwigVectorSizetVector v)

SwigVectorSizetVector_swiginit(...)

SwigVectorSizetVector_swigregister(...)

SwigVectorStringVector___bool__(...)
SwigVectorStringVector___bool__(SwigVectorStringVector self) -> bool

SwigVectorStringVector___delitem__(...)
__delitem__(std::vector< std::vector< std::string > >::difference_type i) SwigVectorStringVector___delitem__(SwigVectorStringVector self, PySliceObject * slice)

SwigVectorStringVector___delslice__(...)
SwigVectorStringVector___delslice__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j)

SwigVectorStringVector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorStringVector SwigVectorStringVector___getitem__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i) -> SwigStringVector

SwigVectorStringVector___getslice__(...)
SwigVectorStringVector___getslice__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j) -> SwigVectorStringVector

SwigVectorStringVector___len__(...)
SwigVectorStringVector___len__(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::size_type

SwigVectorStringVector___nonzero__(...)
SwigVectorStringVector___nonzero__(SwigVectorStringVector self) -> bool

SwigVectorStringVector___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorStringVector v) __setitem__(PySliceObject * slice) SwigVectorStringVector___setitem__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, SwigStringVector x)

SwigVectorStringVector___setslice__(...)
__setslice__(std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j) SwigVectorStringVector___setslice__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, std::vector< std::vector< std::string > >::difference_type j, SwigVectorStringVector v)

SwigVectorStringVector_append(...)
SwigVectorStringVector_append(SwigVectorStringVector self, SwigStringVector x)

SwigVectorStringVector_assign(...)
SwigVectorStringVector_assign(SwigVectorStringVector self, std::vector< std::vector< std::string > >::size_type n, SwigStringVector x)

SwigVectorStringVector_back(...)
SwigVectorStringVector_back(SwigVectorStringVector self) -> SwigStringVector

SwigVectorStringVector_begin(...)
SwigVectorStringVector_begin(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::iterator

SwigVectorStringVector_capacity(...)
SwigVectorStringVector_capacity(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::size_type

SwigVectorStringVector_clear(...)
SwigVectorStringVector_clear(SwigVectorStringVector self)

SwigVectorStringVector_empty(...)
SwigVectorStringVector_empty(SwigVectorStringVector self) -> bool

SwigVectorStringVector_end(...)
SwigVectorStringVector_end(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::iterator

SwigVectorStringVector_erase(...)
erase(std::vector< std::vector< std::string > >::iterator pos) -> std::vector< std::vector< std::string > >::iterator SwigVectorStringVector_erase(SwigVectorStringVector self, std::vector< std::vector< std::string > >::iterator first, std::vector< std::vector< std::string > >::iterator last) -> std::vector< std::vector< std::string > >::iterator

SwigVectorStringVector_front(...)
SwigVectorStringVector_front(SwigVectorStringVector self) -> SwigStringVector

SwigVectorStringVector_get_allocator(...)
SwigVectorStringVector_get_allocator(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::allocator_type

SwigVectorStringVector_insert(...)
insert(std::vector< std::vector< std::string > >::iterator pos, SwigStringVector x) -> std::vector< std::vector< std::string > >::iterator SwigVectorStringVector_insert(SwigVectorStringVector self, std::vector< std::vector< std::string > >::iterator pos, std::vector< std::vector< std::string > >::size_type n, SwigStringVector x)

SwigVectorStringVector_iterator(...)
SwigVectorStringVector_iterator(SwigVectorStringVector self) -> SwigPyIterator

SwigVectorStringVector_pop(...)
SwigVectorStringVector_pop(SwigVectorStringVector self) -> SwigStringVector

SwigVectorStringVector_pop_back(...)
SwigVectorStringVector_pop_back(SwigVectorStringVector self)

SwigVectorStringVector_push_back(...)
SwigVectorStringVector_push_back(SwigVectorStringVector self, SwigStringVector x)

SwigVectorStringVector_rbegin(...)
SwigVectorStringVector_rbegin(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::reverse_iterator

SwigVectorStringVector_rend(...)
SwigVectorStringVector_rend(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::reverse_iterator

SwigVectorStringVector_reserve(...)
SwigVectorStringVector_reserve(SwigVectorStringVector self, std::vector< std::vector< std::string > >::size_type n)

SwigVectorStringVector_resize(...)
resize(std::vector< std::vector< std::string > >::size_type new_size) SwigVectorStringVector_resize(SwigVectorStringVector self, std::vector< std::vector< std::string > >::size_type new_size, SwigStringVector x)

SwigVectorStringVector_size(...)
SwigVectorStringVector_size(SwigVectorStringVector self) -> std::vector< std::vector< std::string > >::size_type

SwigVectorStringVector_swap(...)
SwigVectorStringVector_swap(SwigVectorStringVector self, SwigVectorStringVector v)

SwigVectorStringVector_swiginit(...)

SwigVectorStringVector_swigregister(...)

addStaticDummyAtom(...)
addStaticDummyAtom(MM_Index staticFrag, std::string const & fragType, SwigDoubleVector xyz, int bondedTo=0)

checkStaticFrag(...)
checkStaticFrag(std::string const & fragType, size_t npoints, std::string mesg)

conformerBlockPositions(...)
conformerBlockPositions(std::string const & structure_file, std::string title_property, bool use_titles=False, bool use_stereo=True, bool use_annotations=False) -> SwigSizetVector

coordsMatch(...)
coordsMatch(MM_Index ct, int atom, SwigDoubleVector coords, double tol) -> bool

createLocateSite(...)
createLocateSite(PhpBaseFeature const & bf) -> PhpLocateSitePoint *

createStaticFrag(...)
createStaticFrag(PhpSite staticSite) -> MM_Index

createStaticMol(...)
createStaticMol(std::vector< PhpSite,std::allocator< PhpSite > > const & sites, MM_Index ctStart) -> MM_Index

createStaticSite(...)
createStaticSite(std::string const & fragType, SwigVectorDoubleVector xyz) -> PhpSite createStaticSite(PhpSite site) -> PhpSite

deleteAllAtoms(...)
deleteAllAtoms(MM_Index ct)

delete_PhpAlignCore(...)
delete_PhpAlignCore(PhpAlignCore self)

delete_PhpAtomClassDescriptions(...)
delete_PhpAtomClassDescriptions(PhpAtomClassDescriptions self)

delete_PhpComplex(...)
delete_PhpComplex(PhpComplex self)

delete_PhpDatabaseFp(...)
delete_PhpDatabaseFp(PhpDatabaseFp self)

delete_PhpDeNovoPharm(...)
delete_PhpDeNovoPharm(PhpDeNovoPharm self)

delete_PhpDeltaHypo(...)
delete_PhpDeltaHypo(PhpDeltaHypo self)

delete_PhpDeltaHypoSite(...)
delete_PhpDeltaHypoSite(PhpDeltaHypoSite self)

delete_PhpException(...)
delete_PhpException(PhpException self)

delete_PhpExclVol(...)
delete_PhpExclVol(PhpExclVol self)

delete_PhpExclVolSphere(...)
delete_PhpExclVolSphere(PhpExclVolSphere self)

delete_PhpFastShape(...)
delete_PhpFastShape(PhpFastShape self)

delete_PhpFastShapePair(...)
delete_PhpFastShapePair(PhpFastShapePair self)

delete_PhpFeatureClassDescriptions(...)
delete_PhpFeatureClassDescriptions(PhpFeatureClassDescriptions self)

delete_PhpFeatureData(...)
delete_PhpFeatureData(PhpFeatureData self)

delete_PhpFeatureDefinition(...)
delete_PhpFeatureDefinition(PhpFeatureDefinition self)

delete_PhpFeatureFinder(...)
delete_PhpFeatureFinder(PhpFeatureFinder self)

delete_PhpFeaturePattern(...)
delete_PhpFeaturePattern(PhpFeaturePattern self)

delete_PhpFeatureRules(...)
delete_PhpFeatureRules(PhpFeatureRules self)

delete_PhpFragPair(...)
delete_PhpFragPair(PhpFragPair self)

delete_PhpHiCluster(...)
delete_PhpHiCluster(PhpHiCluster self)

delete_PhpHiClusterPair(...)
delete_PhpHiClusterPair(PhpHiClusterPair self)

delete_PhpHypoAdaptor(...)
delete_PhpHypoAdaptor(PhpHypoAdaptor self)

delete_PhpIntCoord(...)
delete_PhpIntCoord(PhpIntCoord self)

delete_PhpPackedFp(...)
delete_PhpPackedFp(PhpPackedFp self)

delete_PhpProject(...)
delete_PhpProject(PhpProject self)

delete_PhpQSAR(...)
delete_PhpQSAR(PhpQSAR self)

delete_PhpQSARModel(...)
delete_PhpQSARModel(PhpQSARModel self)

delete_PhpSite(...)
delete_PhpSite(PhpSite self)

delete_PhpSiteConstrainer(...)
delete_PhpSiteConstrainer(PhpSiteConstrainer self)

delete_PhpSiteConstraint(...)
delete_PhpSiteConstraint(PhpSiteConstraint self)

delete_PhpSiteMask(...)
delete_PhpSiteMask(PhpSiteMask self)

delete_PhpSiteMaskData(...)
delete_PhpSiteMaskData(PhpSiteMaskData self)

delete_PhpSiteMaskGroup(...)
delete_PhpSiteMaskGroup(PhpSiteMaskGroup self)

delete_PhpSiteWithAtoms(...)
delete_PhpSiteWithAtoms(PhpSiteWithAtoms self)

delete_PhpVolCoords(...)
delete_PhpVolCoords(PhpVolCoords self)

delete_SwigDoubleVector(...)
delete_SwigDoubleVector(SwigDoubleVector self)

delete_SwigIntVector(...)
delete_SwigIntVector(SwigIntVector self)

delete_SwigPhpFpTypeVector(...)
delete_SwigPhpFpTypeVector(SwigPhpFpTypeVector self)

delete_SwigPyIterator(...)
delete_SwigPyIterator(SwigPyIterator self)

delete_SwigSizetVector(...)
delete_SwigSizetVector(SwigSizetVector self)

delete_SwigStringVector(...)
delete_SwigStringVector(SwigStringVector self)

delete_SwigUnsignedIntVector(...)
delete_SwigUnsignedIntVector(SwigUnsignedIntVector self)

delete_SwigVectorDoubleVector(...)
delete_SwigVectorDoubleVector(SwigVectorDoubleVector self)

delete_SwigVectorIntVector(...)
delete_SwigVectorIntVector(SwigVectorIntVector self)

delete_SwigVectorPhpSitePhpSite(...)
delete_SwigVectorPhpSitePhpSite(SwigVectorPhpSitePhpSite self)

delete_SwigVectorSizetVector(...)
delete_SwigVectorSizetVector(SwigVectorSizetVector self)

delete_SwigVectorStringVector(...)
delete_SwigVectorStringVector(SwigVectorStringVector self)

findFirstQSite(...)
findFirstQSite(std::vector< PhpSite,std::allocator< PhpSite > > const & sites) -> size_t

generateLcsMapFromBaseFeatures(...)
generateLcsMapFromBaseFeatures(std::vector< PhpBaseFeature,std::allocator< PhpBaseFeature > > const & features) -> PhpLcsMap

generateSitesFromBaseFeatures(...)
generateSitesFromBaseFeatures(std::vector< PhpBaseFeature,std::allocator< PhpBaseFeature > > const & features, std::vector< PhpAtom,std::allocator< PhpAtom > > const & atoms) -> std::vector< PhpSite,std::allocator< PhpSite > >

getCtTitle(...)
getCtTitle(MM_Index ctHandle) -> std::string

std::string

getDefaultFdFileBaseName()

std::string

getDefaultFdFilePath()

getFragAtomID(...)
getFragAtomID(std::string const & fragType, size_t atomIndex) -> std::string

getFragAtoms(...)
getFragAtoms(MM_Index ct, PhpSite site, double tol) -> SwigIntVector

getListOfBondedAtoms(...)
getListOfBondedAtoms(MM_Index ct, size_t atom) -> SwigSizetVector

getLongLine(...)
getLongLine(std::istream & istr, std::string & s) -> std::istream &

getNonQCount(...)
getNonQCount(std::vector< PhpBaseFeature,std::allocator< PhpBaseFeature > > const & features) -> int

getPhpFunction(...)
getPhpFunction(std::string const & boostFunction) -> std::string

getTopoDistanceMatrix(...)
getTopoDistanceMatrix(MM_Index ctHandle) -> SwigVectorIntVector getTopoDistanceMatrix(MM_Index ctHandle, SwigVectorIntVector brokenBonds) -> SwigVectorIntVector

initMMlibs()

isInVector(...)
isInVector(SwigIntVector values, int value) -> bool

new_PhpAlignCore(...)
PhpAlignCore(MM_Index ctHandleA, MM_Index ctHandleB, std::string const & smarts, bool allowStereoFailure=False, bool noCarry=False, bool inversionsOnly=False) PhpAlignCore(MM_Index ctHandleA, MM_Index ctHandleB, std::vector< PhpCoreMapping,std::allocator< PhpCoreMapping > > const & mappings, bool allowStereoFailure=False, bool noCarry=False, bool inversionsOnly=False) PhpAlignCore(MM_Index ctHandleA, MM_Index ctHandleB, SwigIntVector atomsA, SwigIntVector atomsB, bool allowStereoFailure=False, bool noCarry=False, bool inversionsOnly=False, std::string debugMaeFile) PhpAlignCore(MM_Index ctHandleA, MM_Index ctHandleB, SwigIntVector atomsA, SwigIntVector atomsB, SwigVectorIntVector brokenBonds, bool allowStereoFailure=False, bool noCarry=False, bool inversionsOnly=False, std::string debugMaeFile) new_PhpAlignCore(PhpAlignCore rhs) -> PhpAlignCore

PhpAtomClassDescriptions

new_PhpAtomClassDescriptions()

new_PhpComplex()
new_PhpComplex(PhpComplex rhs) -> PhpComplex

new_PhpDatabaseFp(...)
new_PhpDatabaseFp(std::string const & dbName) -> PhpDatabaseFp

new_PhpDeNovoPharm(...)
PhpDeNovoPharm(MM_Index receptor, SwigIntVector bindingSiteAtoms, double distAD=2.0, double distRR=4.0, double distBuff=1.0, double angleLRC=45.0) new_PhpDeNovoPharm(MM_Index receptor, SwigIntVector bindingSiteAtoms, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, double distAD=2.0, double distRR=4.0, double distBuff=1.0, double angleLRC=45.0) -> PhpDeNovoPharm

new_PhpDeltaHypo()
new_PhpDeltaHypo(PhpDeltaHypo rhs) -> PhpDeltaHypo

PhpDeltaHypoSite

new_PhpDeltaHypoSite()

new_PhpException()
PhpException(PhpException rhs) PhpException(std::string const & message) new_PhpException(std::string const & message, int err_code) -> PhpException

new_PhpExclVol()
new_PhpExclVol(PhpExclVol rhs) -> PhpExclVol

PhpExclVolSphere

new_PhpExclVolSphere()

new_PhpFastShape(...)
PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, int norm, int maxMap=8, int maxAlt=1) PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, SwigIntVector stype, int norm, int maxMap=8, int maxAlt=1) PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, SwigIntVector stype, SwigDoubleVector weight, int norm, int maxMap=8, int maxAlt=1) PhpFastShape(MM_Index ctHandle, int hydrogens, std::string const & atype, std::string const & weight, int norm, int maxMap=8, int maxAlt=1) PhpFastShape(std::vector< PhpSite,std::allocator< PhpSite > > const & sites, PhpFeatureData radii, PhpLcsMap const & lcsMap, int norm, int maxMap=8, int maxAlt=1) new_PhpFastShape(PhpFastShape rhs) -> PhpFastShape

PhpFastShapePair

new_PhpFastShapePair()

PhpFeatureClassDescriptions

new_PhpFeatureClassDescriptions()

new_PhpFeatureData()
new_PhpFeatureData(PhpFeatureData rhs) -> PhpFeatureData

new_PhpFeatureDefinition()
new_PhpFeatureDefinition(PhpFeatureDefinition rhs) -> PhpFeatureDefinition

new_PhpFeatureFinder()
new_PhpFeatureFinder(PhpFeatureFinder rhs) -> PhpFeatureFinder

new_PhpFeaturePattern()
new_PhpFeaturePattern(PhpFeaturePattern rhs) -> PhpFeaturePattern

new_PhpFeatureRules()
new_PhpFeatureRules(PhpFeatureRules rhs) -> PhpFeatureRules

PhpFragPair

new_PhpFragPair()

new_PhpHiCluster()
new_PhpHiCluster(PhpHiCluster rhs) -> PhpHiCluster

PhpHiClusterPair

new_PhpHiClusterPair()

new_PhpHypoAdaptor(...)
PhpHypoAdaptor(std::string const & hypoID, bool remap=False) PhpHypoAdaptor(std::string const & hypoID, std::vector< PhpSite,std::allocator< PhpSite > > const & sites, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd) PhpHypoAdaptor(std::string const & hypoID, std::vector< PhpSite,std::allocator< PhpSite > > const & sites, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, MM_Index refCt, bool remap=False) PhpHypoAdaptor(std::string const & hypoID, std::vector< PhpSite,std::allocator< PhpSite > > const & refCtSites, std::vector< PhpSite,std::allocator< PhpSite > > const & staticSites, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, MM_Index refCt) PhpHypoAdaptor(std::string const & hypoID, std::string const & hypoArchive, MM_Index refCt) PhpHypoAdaptor(MM_Index hypoCt) PhpHypoAdaptor(MM_Index hypoCt, MM_Index refCt) PhpHypoAdaptor(MM_Index hypoCt, MM_Index refCt, SwigIntVector addCts) new_PhpHypoAdaptor(PhpHypoAdaptor rhs) -> PhpHypoAdaptor

PhpIntCoord

new_PhpIntCoord()

new_PhpPackedFp()
PhpPackedFp(size_t u_molID, std::string const & u_bits, size_t u_lenOrig) new_PhpPackedFp(PhpPackedFp rhs) -> PhpPackedFp

PhpProject

new_PhpProject()

new_PhpQSAR()
new_PhpQSAR(PhpQSAR rhs) -> PhpQSAR

PhpQSARModel

new_PhpQSARModel()

new_PhpSite()
PhpSite(size_t a_number) PhpSite(std::string const & a_type) new_PhpSite(PhpSite arg2) -> PhpSite

new_PhpSiteConstrainer()
new_PhpSiteConstrainer(PhpSiteConstrainer rhs) -> PhpSiteConstrainer

new_PhpSiteConstraint()
PhpSiteConstraint(SwigIntVector u_siteIndices, std::string const & u_siteTypes, double u_value, double u_tol) new_PhpSiteConstraint(PhpSiteConstraint rhs) -> PhpSiteConstraint

new_PhpSiteMask()
new_PhpSiteMask(PhpSiteMask rhs) -> PhpSiteMask

new_PhpSiteMaskData()
PhpSiteMaskData(int u_siteNumber, char u_siteType, int u_maskValue) new_PhpSiteMaskData(PhpSiteMaskData rhs) -> PhpSiteMaskData

new_PhpSiteMaskGroup()
PhpSiteMaskGroup(SwigIntVector u_siteIndices, size_t minMatch, size_t groupNumber) new_PhpSiteMaskGroup(PhpSiteMaskGroup rhs) -> PhpSiteMaskGroup

PhpSiteWithAtoms

new_PhpSiteWithAtoms()

PhpVolCoords

new_PhpVolCoords()

new_SwigDoubleVector()
SwigDoubleVector(SwigDoubleVector arg2) SwigDoubleVector(std::vector< double >::size_type size) new_SwigDoubleVector(std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> SwigDoubleVector

new_SwigIntVector()
SwigIntVector(SwigIntVector arg2) SwigIntVector(std::vector< int >::size_type size) new_SwigIntVector(std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> SwigIntVector

new_SwigPhpFpTypeVector()
SwigPhpFpTypeVector(SwigPhpFpTypeVector arg2) SwigPhpFpTypeVector(std::vector< enum PhpFpType >::size_type size) new_SwigPhpFpTypeVector(std::vector< enum PhpFpType >::size_type size, std::vector< enum PhpFpType >::value_type const & value) -> SwigPhpFpTypeVector

new_SwigSizetVector()
SwigSizetVector(SwigSizetVector arg2) SwigSizetVector(std::vector< size_t >::size_type size) new_SwigSizetVector(std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> SwigSizetVector

new_SwigStringVector()
SwigStringVector(SwigStringVector arg2) SwigStringVector(std::vector< std::string >::size_type size) new_SwigStringVector(std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> SwigStringVector

new_SwigUnsignedIntVector()
SwigUnsignedIntVector(SwigUnsignedIntVector arg2) SwigUnsignedIntVector(std::vector< unsigned int >::size_type size) new_SwigUnsignedIntVector(std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> SwigUnsignedIntVector

new_SwigVectorDoubleVector()
SwigVectorDoubleVector(SwigVectorDoubleVector arg2) SwigVectorDoubleVector(std::vector< std::vector< double > >::size_type size) new_SwigVectorDoubleVector(std::vector< std::vector< double > >::size_type size, SwigDoubleVector value) -> SwigVectorDoubleVector

new_SwigVectorIntVector()
SwigVectorIntVector(SwigVectorIntVector arg2) SwigVectorIntVector(std::vector< std::vector< int > >::size_type size) new_SwigVectorIntVector(std::vector< std::vector< int > >::size_type size, SwigIntVector value) -> SwigVectorIntVector

new_SwigVectorPhpSitePhpSite()
SwigVectorPhpSitePhpSite(SwigVectorPhpSitePhpSite arg2) SwigVectorPhpSitePhpSite(std::vector< std::pair< PhpSite,PhpSite > >::size_type size) new_SwigVectorPhpSitePhpSite(std::vector< std::pair< PhpSite,PhpSite > >::size_type size, std::vector< std::pair< PhpSite,PhpSite > >::value_type const & value) -> SwigVectorPhpSitePhpSite

new_SwigVectorSizetVector()
SwigVectorSizetVector(SwigVectorSizetVector arg2) SwigVectorSizetVector(std::vector< std::vector< size_t > >::size_type size) new_SwigVectorSizetVector(std::vector< std::vector< size_t > >::size_type size, SwigSizetVector value) -> SwigVectorSizetVector

new_SwigVectorStringVector()
SwigVectorStringVector(SwigVectorStringVector arg2) SwigVectorStringVector(std::vector< std::vector< std::string > >::size_type size) new_SwigVectorStringVector(std::vector< std::vector< std::string > >::size_type size, SwigStringVector value) -> SwigVectorStringVector

printVectorValues(...)
printVectorValues(SwigIntVector values, std::string sep, std::string lastSep) -> std::string

tokenizeDelimitedString(...)
tokenizeDelimitedString(std::string const & s, char sep, bool trim=False) -> SwigStringVector

Variables

[hide private]

FP_TYPE_DENDRITIC = 0
hash(x)

FP_TYPE_ECFP4 = 6

FP_TYPE_ECFP6 = 7

FP_TYPE_FCFP4 = 8

FP_TYPE_FCFP6 = 9

FP_TYPE_FDENDRITIC = 1

FP_TYPE_LINEAR = 2

FP_TYPE_MACCS = 3
hash(x)

FP_TYPE_MOLPRINT2D = 4

FP_TYPE_RADIAL = 5

PhpSite_SiteStatusOff = 1

PhpSite_SiteStatusOn = 0
hash(x)

__package__ = None
hash(x)

cvar = <Swig global variables>