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, ...

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(...)

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(...)
PhpExclVol_addSphere(PhpExclVol self, double x, double y, double z, double r)

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_findViolations(...)
PhpExclVol_findViolations(PhpExclVol self, MM_Index ctHandle, size_t maxViolations) -> SwigSizetVector

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

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

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, ...

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 arg2) -> bool

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

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 arg2) -> 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_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(...)

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_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_convert(...)
PhpHypoAdaptor_convert(PhpHypoAdaptor self, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd)

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

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_getFragCount(...)
PhpHypoAdaptor_getFragCount(PhpHypoAdaptor self) -> int

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

PhpHypoAdaptor_getFragMap(...)
PhpHypoAdaptor_getFragMap(PhpHypoAdaptor self) -> SwigVectorIntVector

PhpHypoAdaptor_getFragSites(...)
PhpHypoAdaptor_getFragSites(PhpHypoAdaptor self) -> std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > >

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) -> std::vector< PhpSite,std::allocator< PhpSite > >

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

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

PhpHypoAdaptor_getSiteTypes(...)
PhpHypoAdaptor_getSiteTypes(PhpHypoAdaptor self) -> 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_hasFrag(...)
PhpHypoAdaptor_hasFrag(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_save(...)
PhpHypoAdaptor_save(PhpHypoAdaptor self, std::string const & hypoID, bool overwrite)

PhpHypoAdaptor_setFrag(...)
PhpHypoAdaptor_setFrag(PhpHypoAdaptor self, SwigIntVector fragCts, std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > > const & fragSites, ...

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

PhpHypoAdaptor_swiginit(...)

PhpHypoAdaptor_swigregister(...)

PhpHypoAdaptor_writeSummary(...)
PhpHypoAdaptor_writeSummary(PhpHypoAdaptor self, std::ostream & os)

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(...)

PhpProject_addLigands(...)
PhpProject_addLigands(PhpProject self, std::string const & projectName, std::string const & inFile, bool connect, ...

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, ...

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, ...

PhpProject_closeProject(...)
PhpProject_closeProject(PhpProject self)

PhpProject_combineFragmentCts(...)
PhpProject_combineFragmentCts(PhpProject self, SwigIntVector fragments) -> MM_Index

PhpProject_combineFragmentSites(...)
PhpProject_combineFragmentSites(PhpProject self, SwigIntVector fragCts, std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > > const & fragSites, ...

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, ...

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, ...

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

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

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

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

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_getSiteFragment(...)
PhpProject_getSiteFragment(PhpProject self, std::string const & siteType, SwigDoubleVector xyz1, SwigDoubleVector xyz2) -> MM_Index

PhpProject_getSiteMappings(...)
PhpProject_getSiteMappings(PhpProject self, PhpSite site, std::vector< PhpSite,std::allocator< PhpSite > > const & pool, ...

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, ...

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

PhpProject_newProject(...)
PhpProject_newProject(PhpProject self, std::string const & projectName, std::string const & inFile, std::string const & fdFile, ...

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, ...

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, ...

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, ...

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, ...

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, ...

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, ...

PhpQSAR_createModel(...)
createModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, ...

PhpQSAR_crossValidateModel(...)
crossValidateModel(size_t n, size_t randSeed, SwigVectorDoubleVector yhatLNO, SwigDoubleVector rsqrYobs, ...

PhpQSAR_duplexDataSet(...)
duplexDataSet(size_t numTotal, size_t numTrain, size_t & randomSeed, SwigSizetVector trainList, ...

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, ...

PhpQSAR_printDelimitedBits(...)
PhpQSAR_printDelimitedBits(PhpQSAR self, std::ostream & outStream, SwigSizetVector observations, SwigStringVector qsarSet, ...

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, ...

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

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, ...

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...

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, ...

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(...)

PhpSite___eq__(...)
PhpSite___eq__(PhpSite self, PhpSite arg2) -> 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_getProjectedOnly(...)
PhpSite_getProjectedOnly(PhpSite self) -> bool

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_getXCoord(...)
PhpSite_getXCoord(PhpSite self) -> double

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

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

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

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

PhpSite_setProjectedOnlyOff(...)
PhpSite_setProjectedOnlyOff(PhpSite self)

PhpSite_setProjectedOnlyOn(...)
PhpSite_setProjectedOnlyOn(PhpSite self)

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 const a_status)

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

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__(...)
SwigDoubleVector___setslice__(SwigDoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, ...

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_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__(...)
SwigIntVector___setslice__(SwigIntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, ...

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_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(...)

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__(...)
SwigSizetVector___setslice__(SwigSizetVector self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, ...

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_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__(...)
SwigStringVector___setslice__(SwigStringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, ...

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_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(...)

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, ...

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, ...

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)...

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

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_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_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_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__(...)
SwigVectorIntVector___setslice__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, ...

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_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_size(...)
SwigVectorIntVector_size(SwigVectorIntVector self) -> std::vector< std::vector< int > >::size_type

SwigVectorIntVector_swap(...)
SwigVectorIntVector_swap(SwigVectorIntVector self, SwigVectorIntVector v)

SwigVectorIntVector_swiginit(...)

SwigVectorIntVector_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, ...

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, ...

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)...

SwigVectorSizetVector___setslice__(...)
SwigVectorSizetVector___setslice__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, ...

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_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_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_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, ...

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, ...

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)...

SwigVectorStringVector___setslice__(...)
SwigVectorStringVector___setslice__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, ...

SwigVectorStringVector_append(...)
SwigVectorStringVector_append(SwigVectorStringVector self, SwigStringVector x)

SwigVectorStringVector_assign(...)
SwigVectorStringVector_assign(SwigVectorStringVector self, std::vector< std::vector< std::string > >::size_type n, ...

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_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_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_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(...)

delete_PhpAlignCore(...)
delete_PhpAlignCore(PhpAlignCore self)

delete_PhpAtomClassDescriptions(...)
delete_PhpAtomClassDescriptions(PhpAtomClassDescriptions self)

delete_PhpComplex(...)
delete_PhpComplex(PhpComplex 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_PhpHiCluster(...)
delete_PhpHiCluster(PhpHiCluster self)

delete_PhpHiClusterPair(...)
delete_PhpHiClusterPair(PhpHiClusterPair self)

delete_PhpHypoAdaptor(...)
delete_PhpHypoAdaptor(PhpHypoAdaptor self)

delete_PhpIntCoord(...)
delete_PhpIntCoord(PhpIntCoord 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_PhpVolCoords(...)
delete_PhpVolCoords(PhpVolCoords self)

delete_SwigDoubleVector(...)
delete_SwigDoubleVector(SwigDoubleVector self)

delete_SwigIntVector(...)
delete_SwigIntVector(SwigIntVector self)

delete_SwigPyIterator(...)
delete_SwigPyIterator(SwigPyIterator self)

delete_SwigSizetVector(...)
delete_SwigSizetVector(SwigSizetVector self)

delete_SwigStringVector(...)
delete_SwigStringVector(SwigStringVector self)

delete_SwigVectorDoubleVector(...)
delete_SwigVectorDoubleVector(SwigVectorDoubleVector self)

delete_SwigVectorIntVector(...)
delete_SwigVectorIntVector(SwigVectorIntVector self)

delete_SwigVectorSizetVector(...)
delete_SwigVectorSizetVector(SwigVectorSizetVector self)

delete_SwigVectorStringVector(...)
delete_SwigVectorStringVector(SwigVectorStringVector self)

std::string

getDefaultFdFileBaseName()

std::string

getDefaultFdFilePath()

getLongLine(...)
getLongLine(std::istream & istr, std::string & s) -> std::istream &

getPhpFunction(...)
getPhpFunction(std::string const & boostFunction) -> std::string

getTopoDistanceMatrix(...)
getTopoDistanceMatrix(MM_Index ctHandle) -> SwigVectorIntVector getTopoDistanceMatrix(MM_Index ctHandle, SwigVectorIntVector brokenBonds) -> SwigVectorIntVector

isInVector(...)
isInVector(SwigIntVector values, int value) -> bool

new_PhpAlignCore(...)
PhpAlignCore(MM_Index ctHandleA, MM_Index ctHandleB, std::string const & smarts, bool allowStereoFailure=False, ...

PhpAtomClassDescriptions

new_PhpAtomClassDescriptions()

new_PhpComplex()
new_PhpComplex(PhpComplex rhs) -> PhpComplex

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=OVERLAP_NORM_MAX, int maxMap=8, ...

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

new_PhpHiCluster()
new_PhpHiCluster(PhpHiCluster rhs) -> PhpHiCluster

PhpHiClusterPair

new_PhpHiClusterPair()

new_PhpHypoAdaptor(...)
PhpHypoAdaptor(std::string const & hypoID, bool remap=False)...

PhpIntCoord

new_PhpIntCoord()

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 arg1) -> 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

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_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_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_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=" or ") -> std::string

tokenizeDelimitedString(...)
tokenizeDelimitedString(std::string const & s, char sep=',') -> SwigStringVector

Variables

[hide private]

PhpSite_SiteStatusOff = 1

PhpSite_SiteStatusOn = 0
hash(x)

__package__ = None
hash(x)

cvar = <Swig global variables>

Function Details

[hide private]

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 > > > >

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)

PhpHypoAdaptor_setFrag(...)


PhpHypoAdaptor_setFrag(PhpHypoAdaptor self, SwigIntVector fragCts, std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > > const & fragSites, 
    SwigVectorIntVector fragMap)

PhpProject_addLigands(...)


PhpProject_addLigands(PhpProject self, 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_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_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_combineFragmentSites(...)


PhpProject_combineFragmentSites(PhpProject self, SwigIntVector fragCts, std::vector< std::vector< PhpSite,std::allocator< PhpSite > >,std::allocator< std::vector< PhpSite,std::allocator< PhpSite > > > > const & fragSites, 
    std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, 
    double tol=0.001, 
    bool allowDup=False) -> PhpHypoAdaptor

PhpProject_copyFile(...)


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

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_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_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_newProject(...)


PhpProject_newProject(PhpProject self, 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="multi", std::string energyProp="")

PhpProject_reviseDatabase(...)


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

PhpProject_saveFeatureDefToFile(...)


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

PhpProject_testQsarModel(...)


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

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_zipProject(...)


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

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_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_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_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_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

PhpSiteConstraint_setConstraint(...)


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

SwigDoubleVector_setslice(...)


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

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)

SwigIntVector_setslice(...)


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

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)

SwigSizetVector_setslice(...)


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

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)

SwigStringVector_setslice(...)


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

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)

SwigVectorDoubleVector_delslice(...)


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

SwigVectorDoubleVector_getslice(...)


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

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(...)


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

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_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_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)

SwigVectorIntVector_setslice(...)


SwigVectorIntVector___setslice__(SwigVectorIntVector self, std::vector< std::vector< int > >::difference_type i, std::vector< std::vector< int > >::difference_type j, 
    SwigVectorIntVector v=std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >())

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_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)

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_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_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(...)


SwigVectorSizetVector___setslice__(SwigVectorSizetVector self, std::vector< std::vector< size_t > >::difference_type i, 
    std::vector< std::vector< size_t > >::difference_type j, SwigVectorSizetVector v=std::vector< std::vector< size_t,std::allocator< size_t > >,std::allocator< std::vector< size_t,std::allocator< size_t > > > >())

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_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_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)

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_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_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(...)


SwigVectorStringVector___setslice__(SwigVectorStringVector self, std::vector< std::vector< std::string > >::difference_type i, 
    std::vector< std::vector< std::string > >::difference_type j, SwigVectorStringVector v=std::vector< std::vector< std::string,std::allocator< std::string > >,std::allocator< std::vector< std::string,std::allocator< std::string > > > >())

SwigVectorStringVector_assign(...)


SwigVectorStringVector_assign(SwigVectorStringVector self, std::vector< std::vector< std::string > >::size_type n, 
    SwigStringVector x)

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_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_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)

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

new_PhpFastShape(...)


PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, int norm=OVERLAP_NORM_MAX, int maxMap=8, 
    int maxAlt=1)
PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, SwigIntVector stype, int norm=OVERLAP_NORM_MAX, 
    int maxMap=8, int maxAlt=1)
PhpFastShape(SwigVectorDoubleVector xyz, SwigDoubleVector r, SwigIntVector stype, SwigDoubleVector weight, 
    int norm=OVERLAP_NORM_MAX, int maxMap=8, int maxAlt=1)
PhpFastShape(MM_Index ctHandle, int hydrogens, std::string const & atype, std::string const & weight, 
    int norm=OVERLAP_NORM_MAX, int maxMap=8, int maxAlt=1)
PhpFastShape(std::vector< PhpSite,std::allocator< PhpSite > > const & sites, PhpFeatureData radii, 
    PhpLcsMap const & lcsMap, int norm=OVERLAP_NORM_MAX, int maxMap=8, int maxAlt=1)
new_PhpFastShape(PhpFastShape rhs) -> PhpFastShape

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::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