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, 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, 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, ostream outStream)

PhpExclVol_findViolations(...)
PhpExclVol_findViolations(PhpExclVol self, MM_Index ctHandle, size_t maxViolations) -> std::vector< size_t,std::allocator< size_t > >

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, 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(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & xyz, ...

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

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

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

PhpFeaturePattern_getAtomList(...)
PhpFeaturePattern_getAtomList(PhpFeaturePattern self) -> std::vector< size_t,std::allocator< size_t > >

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, std::vector< size_t,std::allocator< size_t > > & 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, 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, istream ruleStream)

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

PhpFeatureRules_swiginit(...)

PhpFeatureRules_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_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) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >

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, ostream os)

PhpIntCoord_atoms_get(...)
PhpIntCoord_atoms_get(PhpIntCoord self) -> std::vector< size_t,std::allocator< size_t > > *

PhpIntCoord_atoms_set(...)
PhpIntCoord_atoms_set(PhpIntCoord self, std::vector< size_t,std::allocator< size_t > > * 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) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >

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

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

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

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

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) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > getQsarModelVolCoords(PhpQSAR qsar, std::string const & qsarClass) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > PhpProject_getQsarModelVolCoords(PhpProject self, PhpQSAR qsar, SwigStringVector qsarClasses) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >

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

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, 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, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > & yhatLNO, ...

PhpQSAR_duplexDataSet(...)
duplexDataSet(size_t numTotal, size_t numTrain, size_t & randomSeed, std::vector< size_t,std::allocator< size_t > > & trainList, ...

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

PhpQSAR_exportModelToStream(...)
PhpQSAR_exportModelToStream(PhpQSAR self, 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, std::vector< size_t,std::allocator< size_t > > const & bits) -> std::vector< size_t,std::allocator< size_t > >

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, std::vector< size_t,std::allocator< size_t > > const & 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) -> std::vector< size_t,std::allocator< size_t > > getVolOccBits(size_t imol) -> std::vector< size_t,std::allocator< size_t > > getVolOccBits(PhpMolModel const & molModel, std::string const & atomClass) -> std::vector< size_t,std::allocator< size_t > > getVolOccBits(size_t imol, std::string const & atomClass) -> std::vector< size_t,std::allocator< size_t > > getVolOccBits(PhpMolModel const & molModel, SwigStringVector atomClasses) -> std::vector< size_t,std::allocator< size_t > > PhpQSAR_getVolOccBits(PhpQSAR self, size_t imol, SwigStringVector atomClasses) -> std::vector< size_t,std::allocator< size_t > >

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, 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, ostream outStream, std::vector< size_t,std::allocator< size_t > > const & observations, ...

PhpQSAR_printDelimitedBits(...)
PhpQSAR_printDelimitedBits(PhpQSAR self, ostream outStream, std::vector< size_t,std::allocator< size_t > > const & observations, ...

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

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

PhpQSAR_printVolOccBits(...)
printVolOccBits(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, 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, 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, ostream outStream)

PhpSiteConstrainer_swiginit(...)

PhpSiteConstrainer_swigregister(...)

PhpSiteConstraint_siteIndices_get(...)
PhpSiteConstraint_siteIndices_get(PhpSiteConstraint self) -> std::vector< size_t,std::allocator< size_t > > *

PhpSiteConstraint_siteIndices_set(...)
PhpSiteConstraint_siteIndices_set(PhpSiteConstraint self, std::vector< size_t,std::allocator< size_t > > * 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_maskValue_get(...)
PhpSiteMaskData_maskValue_get(PhpSiteMaskData self) -> int

PhpSiteMaskData_maskValue_set(...)
PhpSiteMaskData_maskValue_set(PhpSiteMaskData self, int 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_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_siteIndices_get(...)
PhpSiteMaskGroup_siteIndices_get(PhpSiteMaskGroup self) -> std::vector< size_t,std::allocator< size_t > > *

PhpSiteMaskGroup_siteIndices_set(...)
PhpSiteMaskGroup_siteIndices_set(PhpSiteMaskGroup self, std::vector< size_t,std::allocator< size_t > > * siteIndices)

PhpSiteMaskGroup_swiginit(...)

PhpSiteMaskGroup_swigregister(...)

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

PhpSiteMask_addSiteMaskGroup(...)
PhpSiteMask_addSiteMaskGroup(PhpSiteMask self, std::vector< size_t,std::allocator< size_t > > const & siteIndices, ...

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, ostream outStream)

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

SwigDoubleVector3___bool__(...)
SwigDoubleVector3___bool__(SwigDoubleVector3 self) -> bool

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

SwigDoubleVector3___delslice__(...)
SwigDoubleVector3___delslice__(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::difference_type i, ...

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

SwigDoubleVector3___getslice__(...)
SwigDoubleVector3___getslice__(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::difference_type i, ...

SwigDoubleVector3___len__(...)
SwigDoubleVector3___len__(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::size_type

SwigDoubleVector3___nonzero__(...)
SwigDoubleVector3___nonzero__(SwigDoubleVector3 self) -> bool

SwigDoubleVector3___setitem__(...)
__setitem__(PySliceObject * slice, SwigDoubleVector3 v)...

SwigDoubleVector3___setslice__(...)
SwigDoubleVector3___setslice__(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::difference_type i, ...

SwigDoubleVector3_append(...)
SwigDoubleVector3_append(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::value_type const & x)

SwigDoubleVector3_assign(...)
SwigDoubleVector3_assign(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::size_type n, ...

SwigDoubleVector3_back(...)
SwigDoubleVector3_back(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::value_type const &

SwigDoubleVector3_begin(...)
SwigDoubleVector3_begin(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::iterator

SwigDoubleVector3_capacity(...)
SwigDoubleVector3_capacity(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::size_type

SwigDoubleVector3_clear(...)
SwigDoubleVector3_clear(SwigDoubleVector3 self)

SwigDoubleVector3_empty(...)
SwigDoubleVector3_empty(SwigDoubleVector3 self) -> bool

SwigDoubleVector3_end(...)
SwigDoubleVector3_end(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::iterator

SwigDoubleVector3_erase(...)
erase(std::vector< std::vector< std::vector< double > > >::iterator pos) -> std::vector< std::vector< std::vector< double > > >::iterator...

SwigDoubleVector3_front(...)
SwigDoubleVector3_front(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::value_type const &

SwigDoubleVector3_get_allocator(...)
SwigDoubleVector3_get_allocator(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::allocator_type

SwigDoubleVector3_insert(...)
insert(std::vector< std::vector< std::vector< double > > >::iterator pos, std::vector< std::vector< std::vector< double > > >::value_type const & x) -> std::vector< std::vector< std::vector< double > > >::iterator...

SwigDoubleVector3_iterator(...)
SwigDoubleVector3_iterator(SwigDoubleVector3 self) -> SwigPyIterator

SwigDoubleVector3_pop(...)
SwigDoubleVector3_pop(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::value_type

SwigDoubleVector3_pop_back(...)
SwigDoubleVector3_pop_back(SwigDoubleVector3 self)

SwigDoubleVector3_push_back(...)
SwigDoubleVector3_push_back(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::value_type const & x)

SwigDoubleVector3_rbegin(...)
SwigDoubleVector3_rbegin(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::reverse_iterator

SwigDoubleVector3_rend(...)
SwigDoubleVector3_rend(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::reverse_iterator

SwigDoubleVector3_reserve(...)
SwigDoubleVector3_reserve(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::size_type n)

SwigDoubleVector3_resize(...)
resize(std::vector< std::vector< std::vector< double > > >::size_type new_size)...

SwigDoubleVector3_size(...)
SwigDoubleVector3_size(SwigDoubleVector3 self) -> std::vector< std::vector< std::vector< double > > >::size_type

SwigDoubleVector3_swap(...)
SwigDoubleVector3_swap(SwigDoubleVector3 self, SwigDoubleVector3 v)

SwigDoubleVector3_swiginit(...)

SwigDoubleVector3_swigregister(...)

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

SwigIntIntPair_first_get(...)
SwigIntIntPair_first_get(SwigIntIntPair self) -> int

SwigIntIntPair_first_set(...)
SwigIntIntPair_first_set(SwigIntIntPair self, int first)

SwigIntIntPair_second_get(...)
SwigIntIntPair_second_get(SwigIntIntPair self) -> int

SwigIntIntPair_second_set(...)
SwigIntIntPair_second_set(SwigIntIntPair self, int second)

SwigIntIntPair_swiginit(...)

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

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

SwigUInt64Vector___bool__(...)
SwigUInt64Vector___bool__(SwigUInt64Vector self) -> bool

SwigUInt64Vector___delitem__(...)
__delitem__(std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i) SwigUInt64Vector___delitem__(SwigUInt64Vector self, PySliceObject * slice)

SwigUInt64Vector___delslice__(...)
SwigUInt64Vector___delslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, ...

SwigUInt64Vector___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigUInt64Vector SwigUInt64Vector___getitem__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const &

SwigUInt64Vector___getslice__(...)
SwigUInt64Vector___getslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, ...

SwigUInt64Vector___len__(...)
SwigUInt64Vector___len__(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type

SwigUInt64Vector___nonzero__(...)
SwigUInt64Vector___nonzero__(SwigUInt64Vector self) -> bool

SwigUInt64Vector___setitem__(...)
__setitem__(PySliceObject * slice, SwigUInt64Vector v)...

SwigUInt64Vector___setslice__(...)
SwigUInt64Vector___setslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, ...

SwigUInt64Vector_append(...)
SwigUInt64Vector_append(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUInt64Vector_assign(...)
SwigUInt64Vector_assign(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type n, ...

SwigUInt64Vector_back(...)
SwigUInt64Vector_back(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const &

SwigUInt64Vector_begin(...)
SwigUInt64Vector_begin(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator

SwigUInt64Vector_capacity(...)
SwigUInt64Vector_capacity(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type

SwigUInt64Vector_clear(...)
SwigUInt64Vector_clear(SwigUInt64Vector self)

SwigUInt64Vector_empty(...)
SwigUInt64Vector_empty(SwigUInt64Vector self) -> bool

SwigUInt64Vector_end(...)
SwigUInt64Vector_end(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator

SwigUInt64Vector_erase(...)
erase(std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator pos) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator...

SwigUInt64Vector_front(...)
SwigUInt64Vector_front(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const &

SwigUInt64Vector_get_allocator(...)
SwigUInt64Vector_get_allocator(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::allocator_type

SwigUInt64Vector_insert(...)
insert(std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator pos, ...

SwigUInt64Vector_iterator(...)
SwigUInt64Vector_iterator(SwigUInt64Vector self) -> SwigPyIterator

SwigUInt64Vector_pop(...)
SwigUInt64Vector_pop(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type

SwigUInt64Vector_pop_back(...)
SwigUInt64Vector_pop_back(SwigUInt64Vector self)

SwigUInt64Vector_push_back(...)
SwigUInt64Vector_push_back(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUInt64Vector_rbegin(...)
SwigUInt64Vector_rbegin(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::reverse_iterator

SwigUInt64Vector_rend(...)
SwigUInt64Vector_rend(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::reverse_iterator

SwigUInt64Vector_reserve(...)
SwigUInt64Vector_reserve(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type n)

SwigUInt64Vector_resize(...)
resize(std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type new_size)...

SwigUInt64Vector_size(...)
SwigUInt64Vector_size(SwigUInt64Vector self) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type

SwigUInt64Vector_swap(...)
SwigUInt64Vector_swap(SwigUInt64Vector self, SwigUInt64Vector v)

SwigUInt64Vector_swiginit(...)

SwigUInt64Vector_swigregister(...)

SwigUnsignedIntVector2___bool__(...)
SwigUnsignedIntVector2___bool__(SwigUnsignedIntVector2 self) -> bool

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

SwigUnsignedIntVector2___delslice__(...)
SwigUnsignedIntVector2___delslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, ...

SwigUnsignedIntVector2___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigUnsignedIntVector2 SwigUnsignedIntVector2___getitem__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i) -> SwigUnsignedIntVector

SwigUnsignedIntVector2___getslice__(...)
SwigUnsignedIntVector2___getslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, ...

SwigUnsignedIntVector2___len__(...)
SwigUnsignedIntVector2___len__(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::size_type

SwigUnsignedIntVector2___nonzero__(...)
SwigUnsignedIntVector2___nonzero__(SwigUnsignedIntVector2 self) -> bool

SwigUnsignedIntVector2___setitem__(...)
__setitem__(PySliceObject * slice, SwigUnsignedIntVector2 v)...

SwigUnsignedIntVector2___setslice__(...)
SwigUnsignedIntVector2___setslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, ...

SwigUnsignedIntVector2_append(...)
SwigUnsignedIntVector2_append(SwigUnsignedIntVector2 self, SwigUnsignedIntVector x)

SwigUnsignedIntVector2_assign(...)
SwigUnsignedIntVector2_assign(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::size_type n, ...

SwigUnsignedIntVector2_back(...)
SwigUnsignedIntVector2_back(SwigUnsignedIntVector2 self) -> SwigUnsignedIntVector

SwigUnsignedIntVector2_begin(...)
SwigUnsignedIntVector2_begin(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::iterator

SwigUnsignedIntVector2_capacity(...)
SwigUnsignedIntVector2_capacity(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::size_type

SwigUnsignedIntVector2_clear(...)
SwigUnsignedIntVector2_clear(SwigUnsignedIntVector2 self)

SwigUnsignedIntVector2_empty(...)
SwigUnsignedIntVector2_empty(SwigUnsignedIntVector2 self) -> bool

SwigUnsignedIntVector2_end(...)
SwigUnsignedIntVector2_end(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::iterator

SwigUnsignedIntVector2_erase(...)
erase(std::vector< std::vector< unsigned int > >::iterator pos) -> std::vector< std::vector< unsigned int > >::iterator...

SwigUnsignedIntVector2_front(...)
SwigUnsignedIntVector2_front(SwigUnsignedIntVector2 self) -> SwigUnsignedIntVector

SwigUnsignedIntVector2_get_allocator(...)
SwigUnsignedIntVector2_get_allocator(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::allocator_type

SwigUnsignedIntVector2_insert(...)
insert(std::vector< std::vector< unsigned int > >::iterator pos, SwigUnsignedIntVector x) -> std::vector< std::vector< unsigned int > >::iterator...

SwigUnsignedIntVector2_iterator(...)
SwigUnsignedIntVector2_iterator(SwigUnsignedIntVector2 self) -> SwigPyIterator

SwigUnsignedIntVector2_pop(...)
SwigUnsignedIntVector2_pop(SwigUnsignedIntVector2 self) -> SwigUnsignedIntVector

SwigUnsignedIntVector2_pop_back(...)
SwigUnsignedIntVector2_pop_back(SwigUnsignedIntVector2 self)

SwigUnsignedIntVector2_push_back(...)
SwigUnsignedIntVector2_push_back(SwigUnsignedIntVector2 self, SwigUnsignedIntVector x)

SwigUnsignedIntVector2_rbegin(...)
SwigUnsignedIntVector2_rbegin(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::reverse_iterator

SwigUnsignedIntVector2_rend(...)
SwigUnsignedIntVector2_rend(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::reverse_iterator

SwigUnsignedIntVector2_reserve(...)
SwigUnsignedIntVector2_reserve(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::size_type n)

SwigUnsignedIntVector2_resize(...)
resize(std::vector< std::vector< unsigned int > >::size_type new_size)...

SwigUnsignedIntVector2_size(...)
SwigUnsignedIntVector2_size(SwigUnsignedIntVector2 self) -> std::vector< std::vector< unsigned int > >::size_type

SwigUnsignedIntVector2_swap(...)
SwigUnsignedIntVector2_swap(SwigUnsignedIntVector2 self, SwigUnsignedIntVector2 v)

SwigUnsignedIntVector2_swiginit(...)

SwigUnsignedIntVector2_swigregister(...)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SwigUnsignedIntVector_clear(...)
SwigUnsignedIntVector_clear(SwigUnsignedIntVector self)

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

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

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

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

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

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

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

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

SwigUnsignedIntVector_pop_back(...)
SwigUnsignedIntVector_pop_back(SwigUnsignedIntVector self)

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

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

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

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

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

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

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

SwigUnsignedIntVector_swiginit(...)

SwigUnsignedIntVector_swigregister(...)

SwigVectorIntIntPair___bool__(...)
SwigVectorIntIntPair___bool__(SwigVectorIntIntPair self) -> bool

SwigVectorIntIntPair___delitem__(...)
__delitem__(std::vector< std::pair< int,int > >::difference_type i) SwigVectorIntIntPair___delitem__(SwigVectorIntIntPair self, PySliceObject * slice)

SwigVectorIntIntPair___delslice__(...)
SwigVectorIntIntPair___delslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, ...

SwigVectorIntIntPair___getitem__(...)
__getitem__(PySliceObject * slice) -> SwigVectorIntIntPair SwigVectorIntIntPair___getitem__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i) -> SwigIntIntPair

SwigVectorIntIntPair___getslice__(...)
SwigVectorIntIntPair___getslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, ...

SwigVectorIntIntPair___len__(...)
SwigVectorIntIntPair___len__(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::size_type

SwigVectorIntIntPair___nonzero__(...)
SwigVectorIntIntPair___nonzero__(SwigVectorIntIntPair self) -> bool

SwigVectorIntIntPair___setitem__(...)
__setitem__(PySliceObject * slice, SwigVectorIntIntPair v)...

SwigVectorIntIntPair___setslice__(...)
SwigVectorIntIntPair___setslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, ...

SwigVectorIntIntPair_append(...)
SwigVectorIntIntPair_append(SwigVectorIntIntPair self, SwigIntIntPair x)

SwigVectorIntIntPair_assign(...)
SwigVectorIntIntPair_assign(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::size_type n, SwigIntIntPair x)

SwigVectorIntIntPair_back(...)
SwigVectorIntIntPair_back(SwigVectorIntIntPair self) -> SwigIntIntPair

SwigVectorIntIntPair_begin(...)
SwigVectorIntIntPair_begin(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::iterator

SwigVectorIntIntPair_capacity(...)
SwigVectorIntIntPair_capacity(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::size_type

SwigVectorIntIntPair_clear(...)
SwigVectorIntIntPair_clear(SwigVectorIntIntPair self)

SwigVectorIntIntPair_empty(...)
SwigVectorIntIntPair_empty(SwigVectorIntIntPair self) -> bool

SwigVectorIntIntPair_end(...)
SwigVectorIntIntPair_end(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::iterator

SwigVectorIntIntPair_erase(...)
erase(std::vector< std::pair< int,int > >::iterator pos) -> std::vector< std::pair< int,int > >::iterator SwigVectorIntIntPair_erase(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::iterator first, std::vector< std::pair< int,int > >::iterator last) -> std::vector< std::pair< int,int > >::iterator

SwigVectorIntIntPair_front(...)
SwigVectorIntIntPair_front(SwigVectorIntIntPair self) -> SwigIntIntPair

SwigVectorIntIntPair_get_allocator(...)
SwigVectorIntIntPair_get_allocator(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::allocator_type

SwigVectorIntIntPair_insert(...)
insert(std::vector< std::pair< int,int > >::iterator pos, SwigIntIntPair x) -> std::vector< std::pair< int,int > >::iterator...

SwigVectorIntIntPair_iterator(...)
SwigVectorIntIntPair_iterator(SwigVectorIntIntPair self) -> SwigPyIterator

SwigVectorIntIntPair_pop(...)
SwigVectorIntIntPair_pop(SwigVectorIntIntPair self) -> SwigIntIntPair

SwigVectorIntIntPair_pop_back(...)
SwigVectorIntIntPair_pop_back(SwigVectorIntIntPair self)

SwigVectorIntIntPair_push_back(...)
SwigVectorIntIntPair_push_back(SwigVectorIntIntPair self, SwigIntIntPair x)

SwigVectorIntIntPair_rbegin(...)
SwigVectorIntIntPair_rbegin(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::reverse_iterator

SwigVectorIntIntPair_rend(...)
SwigVectorIntIntPair_rend(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::reverse_iterator

SwigVectorIntIntPair_reserve(...)
SwigVectorIntIntPair_reserve(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::size_type n)

SwigVectorIntIntPair_resize(...)
resize(std::vector< std::pair< int,int > >::size_type new_size)...

SwigVectorIntIntPair_size(...)
SwigVectorIntIntPair_size(SwigVectorIntIntPair self) -> std::vector< std::pair< int,int > >::size_type

SwigVectorIntIntPair_swap(...)
SwigVectorIntIntPair_swap(SwigVectorIntIntPair self, SwigVectorIntIntPair v)

SwigVectorIntIntPair_swiginit(...)

SwigVectorIntIntPair_swigregister(...)

ostream

_get_cerr()

ostream

_get_cout()

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_PhpFeaturePattern(...)
delete_PhpFeaturePattern(PhpFeaturePattern self)

delete_PhpFeatureRules(...)
delete_PhpFeatureRules(PhpFeatureRules 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_SwigDoubleVector3(...)
delete_SwigDoubleVector3(SwigDoubleVector3 self)

delete_SwigIntIntPair(...)
delete_SwigIntIntPair(SwigIntIntPair self)

delete_SwigIntVector(...)
delete_SwigIntVector(SwigIntVector self)

delete_SwigPyIterator(...)
delete_SwigPyIterator(SwigPyIterator self)

delete_SwigStringVector(...)
delete_SwigStringVector(SwigStringVector self)

delete_SwigUInt64Vector(...)
delete_SwigUInt64Vector(SwigUInt64Vector self)

delete_SwigUnsignedIntVector(...)
delete_SwigUnsignedIntVector(SwigUnsignedIntVector self)

delete_SwigUnsignedIntVector2(...)
delete_SwigUnsignedIntVector2(SwigUnsignedIntVector2 self)

delete_SwigVectorIntIntPair(...)
delete_SwigVectorIntIntPair(SwigVectorIntIntPair self)

delete_ifstream(...)
delete_ifstream(ifstream self)

delete_istream(...)
delete_istream(istream self)

delete_ofstream(...)
delete_ofstream(ofstream self)

delete_ostream(...)
delete_ostream(ostream self)

std::string

getDefaultFdFileBaseName()

std::string

getDefaultFdFilePath()

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

ifstream_close(...)
ifstream_close(ifstream self)

ifstream_is_open(...)
ifstream_is_open(ifstream self) -> bool

ifstream_swiginit(...)

ifstream_swigregister(...)

istream_eof(...)
istream_eof(istream self) -> bool

istream

istream_getline()
istream_getline(istream self, char delim) -> istream

istream_read(...)
istream_read(istream self) -> istream

istream_swigregister(...)

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(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & xyz, ...

PhpFastShapePair

new_PhpFastShapePair()

PhpFeatureClassDescriptions

new_PhpFeatureClassDescriptions()

new_PhpFeatureData()
new_PhpFeatureData(PhpFeatureData rhs) -> PhpFeatureData

new_PhpFeatureDefinition()
new_PhpFeatureDefinition(PhpFeatureDefinition rhs) -> PhpFeatureDefinition

new_PhpFeaturePattern()
new_PhpFeaturePattern(PhpFeaturePattern rhs) -> PhpFeaturePattern

new_PhpFeatureRules()
new_PhpFeatureRules(PhpFeatureRules rhs) -> PhpFeatureRules

new_PhpHypoAdaptor(...)
PhpHypoAdaptor(std::string const & hypoID)...

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

PhpSiteConstraint

new_PhpSiteConstraint()

new_PhpSiteMask()
new_PhpSiteMask(PhpSiteMask rhs) -> PhpSiteMask

PhpSiteMaskData

new_PhpSiteMaskData()

PhpSiteMaskGroup

new_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_SwigDoubleVector3()
SwigDoubleVector3(SwigDoubleVector3 arg2) SwigDoubleVector3(std::vector< std::vector< std::vector< double > > >::size_type size) new_SwigDoubleVector3(std::vector< std::vector< std::vector< double > > >::size_type size, std::vector< std::vector< std::vector< double > > >::value_type const & value) -> SwigDoubleVector3

new_SwigIntIntPair()
SwigIntIntPair(int first, int second) new_SwigIntIntPair(SwigIntIntPair p) -> SwigIntIntPair

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

new_SwigUnsignedIntVector()
SwigUnsignedIntVector(SwigUnsignedIntVector arg2) SwigUnsignedIntVector(std::vector< unsigned int >::size_type size) new_SwigUnsignedIntVector(std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> SwigUnsignedIntVector

new_SwigUnsignedIntVector2()
SwigUnsignedIntVector2(SwigUnsignedIntVector2 arg2) SwigUnsignedIntVector2(std::vector< std::vector< unsigned int > >::size_type size) new_SwigUnsignedIntVector2(std::vector< std::vector< unsigned int > >::size_type size, SwigUnsignedIntVector value) -> SwigUnsignedIntVector2

new_SwigVectorIntIntPair()
SwigVectorIntIntPair(SwigVectorIntIntPair arg2) SwigVectorIntIntPair(std::vector< std::pair< int,int > >::size_type size) new_SwigVectorIntIntPair(std::vector< std::pair< int,int > >::size_type size, SwigIntIntPair value) -> SwigVectorIntIntPair

new_ifstream(...)
new_ifstream(char const * filename) -> ifstream

new_ofstream(...)
new_ofstream(char const * filename) -> ofstream

ofstream_close(...)
ofstream_close(ofstream self)

ofstream_is_open(...)
ofstream_is_open(ofstream self) -> bool

ofstream_swiginit(...)

ofstream_swigregister(...)

ostream_flush(...)
ostream_flush(ostream self) -> ostream

ostream_swigregister(...)

ostream_write(...)
write(char const * buffer, std::streamsize n) -> ostream ostream_write(ostream self, char const * buffer) -> ostream

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(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & xyz, 
    SwigDoubleVector r, 
    bool first, bool inplace, double & sim, double [3] trans, double [3][3] rot)
computeShapeSim(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & 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, 
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & 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) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >

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

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

PhpProject_getMolSitesStrings(...)


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

PhpProject_getSiteMappings(...)


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

PhpProject_mapSites(...)


PhpProject_mapSites(PhpProject self, MM_Index ctHandle, std::vector< PhpFeatureDefinition,std::allocator< PhpFeatureDefinition > > const & fd, 
    std::vector< PhpSite,std::allocator< PhpSite > > * sites, 
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > * 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) -> std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >

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, 
    std::vector< size_t,std::allocator< size_t > > const & trainList, 
    double gridSpacing, double dbuff, size_t maxFactors) -> int
PhpQSAR_createModel(PhpQSAR self, std::vector< size_t,std::allocator< size_t > > const & trainList, double gridSpacing, 
    double dbuff, size_t maxFactors) -> int

PhpQSAR_crossValidateModel(...)


crossValidateModel(size_t n, size_t randSeed, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > & 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, std::vector< size_t,std::allocator< size_t > > & trainList, 
    std::vector< size_t,std::allocator< size_t > > & predList)
PhpQSAR_duplexDataSet(PhpQSAR self, size_t numTrain, size_t & randomSeed, SwigDoubleVector activities, 
    std::vector< size_t,std::allocator< size_t > > & trainList, std::vector< size_t,std::allocator< size_t > > & predList)

PhpQSAR_printDelimitedActivities(...)


PhpQSAR_printDelimitedActivities(PhpQSAR self, ostream outStream, std::vector< size_t,std::allocator< size_t > > const & observations, 
    SwigStringVector qsarSet, std::string const & delim, bool printHeaders=True)

PhpQSAR_printDelimitedBits(...)


PhpQSAR_printDelimitedBits(PhpQSAR self, ostream outStream, std::vector< size_t,std::allocator< size_t > > const & observations, 
    SwigStringVector qsarSet, std::string const & delim, bool printHeaders=True)

PhpQSAR_printPred(...)


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

PhpQSAR_printVolOccBits(...)


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

PhpQSAR_testModel(...)


testModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, 
    std::vector< size_t,std::allocator< size_t > > const & predList, 
    size_t numFactors, SwigDoubleVector predActivities, double & rmsErr, 
    double & qsqr)
testModel(std::vector< size_t,std::allocator< size_t > > const & 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, 
    std::vector< size_t,std::allocator< size_t > > const & predList, 
    size_t numFactors, bool restorePatterns, SwigDoubleVector predActivities, 
    double & rmsErr, double & qsqr)
testModel(std::vector< PhpMolModel,std::allocator< PhpMolModel > > const & molecules, SwigDoubleVector activities, 
    std::vector< size_t,std::allocator< size_t > > const & predList, 
    size_t numFactors1, size_t numFactors2, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > & predActivities, 
    SwigDoubleVector rmsErr, 
    SwigDoubleVector qsqr)
PhpQSAR_testModel(PhpQSAR self, std::vector< size_t,std::allocator< size_t > > const & predList, size_t numFactors1, 
    size_t numFactors2, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > & 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, std::vector< size_t,std::allocator< size_t > > const & refSiteIndices, 
    PhpLigand const & matchedLigand, size_t matchedConfIndex, 
    std::vector< size_t,std::allocator< size_t > > const & 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, 
    std::vector< size_t,std::allocator< size_t > > const & matchedSiteIndices, 
    std::string & reason) -> bool

PhpSiteMask_addSiteMaskGroup(...)


PhpSiteMask_addSiteMaskGroup(PhpSiteMask self, std::vector< size_t,std::allocator< size_t > > const & siteIndices, 
    size_t minMatch)

SwigDoubleVector3_delslice(...)


SwigDoubleVector3___delslice__(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::difference_type i, 
    std::vector< std::vector< std::vector< double > > >::difference_type j)

SwigDoubleVector3_getslice(...)


SwigDoubleVector3___getslice__(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::difference_type i, 
    std::vector< std::vector< std::vector< double > > >::difference_type j) -> SwigDoubleVector3

SwigDoubleVector3_setitem(...)


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

SwigDoubleVector3_setslice(...)


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

SwigDoubleVector3_assign(...)


SwigDoubleVector3_assign(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::size_type n, 
    std::vector< std::vector< std::vector< double > > >::value_type const & x)

SwigDoubleVector3_erase(...)


erase(std::vector< std::vector< std::vector< double > > >::iterator pos) -> std::vector< std::vector< std::vector< double > > >::iterator
SwigDoubleVector3_erase(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::iterator first, 
    std::vector< std::vector< std::vector< double > > >::iterator last) -> std::vector< std::vector< std::vector< double > > >::iterator

SwigDoubleVector3_insert(...)


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

SwigDoubleVector3_resize(...)


resize(std::vector< std::vector< std::vector< double > > >::size_type new_size)
SwigDoubleVector3_resize(SwigDoubleVector3 self, std::vector< std::vector< std::vector< double > > >::size_type new_size, 
    std::vector< std::vector< 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 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)

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)

SwigUInt64Vector_delslice(...)


SwigUInt64Vector___delslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type j)

SwigUInt64Vector_getslice(...)


SwigUInt64Vector___getslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type j) -> SwigUInt64Vector

SwigUInt64Vector_setitem(...)


__setitem__(PySliceObject * slice, SwigUInt64Vector v)
__setitem__(PySliceObject * slice)
SwigUInt64Vector___setitem__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUInt64Vector_setslice(...)


SwigUInt64Vector___setslice__(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type i, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::difference_type j, 
    SwigUInt64Vector v=std::vector< unsigned long long,std::allocator< unsigned long long > >())

SwigUInt64Vector_assign(...)


SwigUInt64Vector_assign(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type n, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUInt64Vector_erase(...)


erase(std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator pos) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator
SwigUInt64Vector_erase(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator first, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator last) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator

SwigUInt64Vector_insert(...)


insert(std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator pos, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x) -> std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator
SwigUInt64Vector_insert(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::iterator pos, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type n, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUInt64Vector_resize(...)


resize(std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type new_size)
SwigUInt64Vector_resize(SwigUInt64Vector self, std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type new_size, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & x)

SwigUnsignedIntVector2_delslice(...)


SwigUnsignedIntVector2___delslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, 
    std::vector< std::vector< unsigned int > >::difference_type j)

SwigUnsignedIntVector2_getslice(...)


SwigUnsignedIntVector2___getslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, 
    std::vector< std::vector< unsigned int > >::difference_type j) -> SwigUnsignedIntVector2

SwigUnsignedIntVector2_setitem(...)


__setitem__(PySliceObject * slice, SwigUnsignedIntVector2 v)
__setitem__(PySliceObject * slice)
SwigUnsignedIntVector2___setitem__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, 
    SwigUnsignedIntVector x)

SwigUnsignedIntVector2_setslice(...)


SwigUnsignedIntVector2___setslice__(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::difference_type i, 
    std::vector< std::vector< unsigned int > >::difference_type j, SwigUnsignedIntVector2 v=std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >())

SwigUnsignedIntVector2_assign(...)


SwigUnsignedIntVector2_assign(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::size_type n, 
    SwigUnsignedIntVector x)

SwigUnsignedIntVector2_erase(...)


erase(std::vector< std::vector< unsigned int > >::iterator pos) -> std::vector< std::vector< unsigned int > >::iterator
SwigUnsignedIntVector2_erase(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::iterator first, 
    std::vector< std::vector< unsigned int > >::iterator last) -> std::vector< std::vector< unsigned int > >::iterator

SwigUnsignedIntVector2_insert(...)


insert(std::vector< std::vector< unsigned int > >::iterator pos, SwigUnsignedIntVector x) -> std::vector< std::vector< unsigned int > >::iterator
SwigUnsignedIntVector2_insert(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::iterator pos, 
    std::vector< std::vector< unsigned int > >::size_type n, SwigUnsignedIntVector x)

SwigUnsignedIntVector2_resize(...)


resize(std::vector< std::vector< unsigned int > >::size_type new_size)
SwigUnsignedIntVector2_resize(SwigUnsignedIntVector2 self, std::vector< std::vector< unsigned int > >::size_type new_size, 
    SwigUnsignedIntVector x)

SwigUnsignedIntVector_setslice(...)


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

SwigUnsignedIntVector_insert(...)


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

SwigVectorIntIntPair_delslice(...)


SwigVectorIntIntPair___delslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, 
    std::vector< std::pair< int,int > >::difference_type j)

SwigVectorIntIntPair_getslice(...)


SwigVectorIntIntPair___getslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, 
    std::vector< std::pair< int,int > >::difference_type j) -> SwigVectorIntIntPair

SwigVectorIntIntPair_setitem(...)


__setitem__(PySliceObject * slice, SwigVectorIntIntPair v)
__setitem__(PySliceObject * slice)
SwigVectorIntIntPair___setitem__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, 
    SwigIntIntPair x)

SwigVectorIntIntPair_setslice(...)


SwigVectorIntIntPair___setslice__(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::difference_type i, 
    std::vector< std::pair< int,int > >::difference_type j, SwigVectorIntIntPair v=std::vector< std::pair< int,int >,std::allocator< std::pair< int,int > > >())

SwigVectorIntIntPair_insert(...)


insert(std::vector< std::pair< int,int > >::iterator pos, SwigIntIntPair x) -> std::vector< std::pair< int,int > >::iterator
SwigVectorIntIntPair_insert(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::iterator pos, std::vector< std::pair< int,int > >::size_type n, 
    SwigIntIntPair x)

SwigVectorIntIntPair_resize(...)


resize(std::vector< std::pair< int,int > >::size_type new_size)
SwigVectorIntIntPair_resize(SwigVectorIntIntPair self, std::vector< std::pair< int,int > >::size_type new_size, 
    SwigIntIntPair 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)
new_PhpAlignCore(PhpAlignCore rhs) -> PhpAlignCore

new_PhpFastShape(...)


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

new_PhpHypoAdaptor(...)


PhpHypoAdaptor(std::string const & hypoID)
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)
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

new_SwigUInt64Vector()

SwigUInt64Vector(SwigUInt64Vector arg2)
SwigUInt64Vector(std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type size)
new_SwigUInt64Vector(std::vector< unsigned long long,std::allocator< unsigned long long > >::size_type size, 
    std::vector< unsigned long long,std::allocator< unsigned long long > >::value_type const & value) -> SwigUInt64Vector