void register_CoordGroupArray_class(){ { //::SireVol::CoordGroupArray typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t; CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") ); bp::scope CoordGroupArray_scope( CoordGroupArray_exposer ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") ); CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") ); CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") ); CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireVol::CoordGroupArray::aaBox typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const; aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox ); CoordGroupArray_exposer.def( "aaBox" , aaBox_function_value , "Return an AABox that complete encompasses all of the CoordGroups\nin this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroup") ) , "Append the passed CoordGroup onto the end of this array" ); } { //::SireVol::CoordGroupArray::append typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ; append_function_type append_function_value( &::SireVol::CoordGroupArray::append ); CoordGroupArray_exposer.def( "append" , append_function_value , ( bp::arg("cgroups") ) , "Append the passed CoordGroups onto the end of this array" ); } { //::SireVol::CoordGroupArray::assertValidCoordGroup typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const; assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup ); CoordGroupArray_exposer.def( "assertValidCoordGroup" , assertValidCoordGroup_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidCoordinate typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const; assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate ); CoordGroupArray_exposer.def( "assertValidCoordinate" , assertValidCoordinate_function_value , ( bp::arg("i") ) , "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::assertValidIndex typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const; assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex ); CoordGroupArray_exposer.def( "assertValidIndex" , assertValidIndex_function_value , ( bp::arg("i") ) , "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::at typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const; at_function_type at_function_value( &::SireVol::CoordGroupArray::at ); CoordGroupArray_exposer.def( "at" , at_function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" ); } { //::SireVol::CoordGroupArray::changeFrame typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame ); CoordGroupArray_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") ) , "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::count typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const; count_function_type count_function_value( &::SireVol::CoordGroupArray::count ); CoordGroupArray_exposer.def( "count" , count_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::isEmpty typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const; isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty ); CoordGroupArray_exposer.def( "isEmpty" , isEmpty_function_value , "Return whether or not this array is empty" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("axes") ) , "Map all of the coordinates in this array into the coordinate\nframe represented by axes" ); } { //::SireVol::CoordGroupArray::mapInto typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto ); CoordGroupArray_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("i"), bp::arg("axes") ) , "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::merge typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const; merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge ); CoordGroupArray_exposer.def( "merge" , merge_function_value , "Merge this array of CoordGroups back into a single CoordGroup" ); } { //::SireVol::CoordGroupArray::nCoordGroups typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const; nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups ); CoordGroupArray_exposer.def( "nCoordGroups" , nCoordGroups_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::nCoords typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const; nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords ); CoordGroupArray_exposer.def( "nCoords" , nCoords_function_value , "Return the number of coordinates in this array" ); } CoordGroupArray_exposer.def( bp::self != bp::self ); { //::SireVol::CoordGroupArray::operator= typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ; assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= ); CoordGroupArray_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } CoordGroupArray_exposer.def( bp::self == bp::self ); { //::SireVol::CoordGroupArray::operator[] typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const; __getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] ); CoordGroupArray_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i") ) , "Remove the ith CoordGroup from the array" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("i"), bp::arg("count") ) , "Remove count CoordGroups from the array, starting with the ith CoordGroup" ); } { //::SireVol::CoordGroupArray::remove typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ; remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove ); CoordGroupArray_exposer.def( "remove" , remove_function_value , ( bp::arg("idxs") ) , "Remove the specified CoordGroups from the array" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("quat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::rotate typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate ); CoordGroupArray_exposer.def( "rotate" , rotate_function_value , ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") ) , "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::size typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const; size_function_type size_function_value( &::SireVol::CoordGroupArray::size ); CoordGroupArray_exposer.def( "size" , size_function_value , "Return the number of CoordGroups in this array" ); } { //::SireVol::CoordGroupArray::toString typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString ); CoordGroupArray_exposer.def( "toString" , toString_function_value , "Return a string representation of this array" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("t") ) , "Transform all of coordinates in this array using the transformation t" ); } { //::SireVol::CoordGroupArray::transform typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform ); CoordGroupArray_exposer.def( "transform" , transform_function_value , ( bp::arg("i"), bp::arg("t") ) , "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) , "Translate all of the coordinates in this array by delta" ); } { //::SireVol::CoordGroupArray::translate typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate ); CoordGroupArray_exposer.def( "translate" , translate_function_value , ( bp::arg("i"), bp::arg("delta") ) , "Translate all of the coordinates in the ith CoordGroup by delta" ); } { //::SireVol::CoordGroupArray::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName ); CoordGroupArray_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("cgroup") ) , "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords") ) , "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::update typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ; update_function_type update_function_value( &::SireVol::CoordGroupArray::update ); CoordGroupArray_exposer.def( "update" , update_function_value , ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") ) , "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" ); } { //::SireVol::CoordGroupArray::what typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const; what_function_type what_function_value( &::SireVol::CoordGroupArray::what ); CoordGroupArray_exposer.def( "what" , what_function_value , "" ); } CoordGroupArray_exposer.staticmethod( "typeName" ); CoordGroupArray_exposer.def( "__copy__", &__copy__); CoordGroupArray_exposer.def( "__deepcopy__", &__copy__); CoordGroupArray_exposer.def( "clone", &__copy__); CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > ); CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > ); } }
void register_Mover_ViewsOfMol__class(){ { //::SireMol::Mover< SireMol::ViewsOfMol > typedef bp::class_< SireMol::Mover< SireMol::ViewsOfMol >, bp::bases< SireMol::MoverBase, SireMol::ViewsOfMol, SireMol::MoleculeView, SireBase::Property > > Mover_ViewsOfMol__exposer_t; Mover_ViewsOfMol__exposer_t Mover_ViewsOfMol__exposer = Mover_ViewsOfMol__exposer_t( "Mover_ViewsOfMol_", bp::init< >() ); bp::scope Mover_ViewsOfMol__scope( Mover_ViewsOfMol__exposer ); Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("view") )) ); Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const &, SireMol::AtomSelection const & >(( bp::arg("view"), bp::arg("movable_atoms") )) ); Mover_ViewsOfMol__exposer.def( bp::init< SireMol::Mover< SireMol::ViewsOfMol > const & >(( bp::arg("other") )) ); { //::SireMol::Mover< SireMol::ViewsOfMol >::align typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ; align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align ); Mover_ViewsOfMol__exposer.def( "align" , align_function_value , ( bp::arg("other"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::align typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ; align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align ); Mover_ViewsOfMol__exposer.def( "align" , align_function_value , ( bp::arg("other"), bp::arg("map0"), bp::arg("map1") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::align typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ; align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align ); Mover_ViewsOfMol__exposer.def( "align" , align_function_value , ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::align typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ; align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align ); Mover_ViewsOfMol__exposer.def( "align" , align_function_value , ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ; alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo ); Mover_ViewsOfMol__exposer.def( "alignTo" , alignTo_function_value , ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ; alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo ); Mover_ViewsOfMol__exposer.def( "alignTo" , alignTo_function_value , ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ; alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo ); Mover_ViewsOfMol__exposer.def( "alignTo" , alignTo_function_value , ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ; alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo ); Mover_ViewsOfMol__exposer.def( "alignTo" , alignTo_function_value , ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::change typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ; change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change ); Mover_ViewsOfMol__exposer.def( "change" , change_function_value , ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::change typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change ); Mover_ViewsOfMol__exposer.def( "change" , change_function_value , ( bp::arg("angle"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::change typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change ); Mover_ViewsOfMol__exposer.def( "change" , change_function_value , ( bp::arg("dihedral"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::change typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change ); Mover_ViewsOfMol__exposer.def( "change" , change_function_value , ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::change typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change ); Mover_ViewsOfMol__exposer.def( "change" , change_function_value , ( bp::arg("improper"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ; changeFrame_function_type changeFrame_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame ); Mover_ViewsOfMol__exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("from_frame"), bp::arg("to_frame"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::commit typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::ViewsOfMol ( ::SireMol::Mover< SireMol::ViewsOfMol >::*commit_function_type )( ) const; commit_function_type commit_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::commit ); Mover_ViewsOfMol__exposer.def( "commit" , commit_function_value ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::mapInto typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*mapInto_function_type )( ::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ; mapInto_function_type mapInto_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::mapInto ); Mover_ViewsOfMol__exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("axes"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::operator= typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::Mover< SireMol::ViewsOfMol > const & ) ; assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= ); Mover_ViewsOfMol__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::operator= typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::ViewsOfMol const & ) ; assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= ); Mover_ViewsOfMol__exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::rotate typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ; rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate ); Mover_ViewsOfMol__exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::rotate typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ; rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate ); Mover_ViewsOfMol__exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::set typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ; set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set ); Mover_ViewsOfMol__exposer.def( "set" , set_function_value , ( bp::arg("bond"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::set typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set ); Mover_ViewsOfMol__exposer.def( "set" , set_function_value , ( bp::arg("angle"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::set typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set ); Mover_ViewsOfMol__exposer.def( "set" , set_function_value , ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::set typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set ); Mover_ViewsOfMol__exposer.def( "set" , set_function_value , ( bp::arg("improper"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::setAll typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*setAll_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ; setAll_function_type setAll_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::setAll ); Mover_ViewsOfMol__exposer.def( "setAll" , setAll_function_value , ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::toString typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::QString ( ::SireMol::Mover< SireMol::ViewsOfMol >::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::toString ); Mover_ViewsOfMol__exposer.def( "toString" , toString_function_value ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::transform typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*transform_function_type )( ::SireMaths::Transform const &,::SireBase::PropertyMap const & ) ; transform_function_type transform_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::transform ); Mover_ViewsOfMol__exposer.def( "transform" , transform_function_value , ( bp::arg("transform"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::translate typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*translate_function_type )( ::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ; translate_function_type translate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::translate ); Mover_ViewsOfMol__exposer.def( "translate" , translate_function_value , ( bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() ) , bp::return_self< >() ); } { //::SireMol::Mover< SireMol::ViewsOfMol >::typeName typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::typeName ); Mover_ViewsOfMol__exposer.def( "typeName" , typeName_function_value ); } Mover_ViewsOfMol__exposer.staticmethod( "typeName" ); Mover_ViewsOfMol__exposer.def( "__copy__", &__copy__); Mover_ViewsOfMol__exposer.def( "__deepcopy__", &__copy__); Mover_ViewsOfMol__exposer.def( "clone", &__copy__); Mover_ViewsOfMol__exposer.def( "__str__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > ); Mover_ViewsOfMol__exposer.def( "__repr__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > ); Mover_ViewsOfMol__exposer.def( "__len__", &__len_count< ::SireMol::Mover<SireMol::ViewsOfMol> > ); } }
void register_NullGrid_class(){ { //::SireVol::NullGrid typedef bp::class_< SireVol::NullGrid, bp::bases< SireVol::Grid, SireBase::Property > > NullGrid_exposer_t; NullGrid_exposer_t NullGrid_exposer = NullGrid_exposer_t( "NullGrid", bp::init< >() ); bp::scope NullGrid_scope( NullGrid_exposer ); NullGrid_exposer.def( bp::init< SireVol::NullGrid const & >(( bp::arg("other") )) ); NullGrid_exposer.def( bp::self != bp::self ); { //::SireVol::NullGrid::operator= typedef ::SireVol::NullGrid & ( ::SireVol::NullGrid::*assign_function_type )( ::SireVol::NullGrid const & ) ; assign_function_type assign_function_value( &::SireVol::NullGrid::operator= ); NullGrid_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } NullGrid_exposer.def( bp::self == bp::self ); { //::SireVol::NullGrid::recenter typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*recenter_function_type )( ::SireMaths::Vector const & ) const; recenter_function_type recenter_function_value( &::SireVol::NullGrid::recenter ); NullGrid_exposer.def( "recenter" , recenter_function_value , ( bp::arg("center") ) ); } { //::SireVol::NullGrid::rotate typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) const; rotate_function_type rotate_function_value( &::SireVol::NullGrid::rotate ); NullGrid_exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("center")=SireMaths::Vector(0.0) ) ); } { //::SireVol::NullGrid::rotate typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) const; rotate_function_type rotate_function_value( &::SireVol::NullGrid::rotate ); NullGrid_exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("center")=SireMaths::Vector(0.0) ) ); } { //::SireVol::NullGrid::scale typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*scale_function_type )( double ) const; scale_function_type scale_function_value( &::SireVol::NullGrid::scale ); NullGrid_exposer.def( "scale" , scale_function_value , ( bp::arg("scalefactor") ) ); } { //::SireVol::NullGrid::translate typedef ::SireVol::GridPtr ( ::SireVol::NullGrid::*translate_function_type )( ::SireMaths::Vector const & ) const; translate_function_type translate_function_value( &::SireVol::NullGrid::translate ); NullGrid_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) ); } { //::SireVol::NullGrid::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireVol::NullGrid::typeName ); NullGrid_exposer.def( "typeName" , typeName_function_value ); } NullGrid_exposer.staticmethod( "typeName" ); NullGrid_exposer.def( "__copy__", &__copy__); NullGrid_exposer.def( "__deepcopy__", &__copy__); NullGrid_exposer.def( "clone", &__copy__); NullGrid_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::NullGrid >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullGrid_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::NullGrid >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); NullGrid_exposer.def( "__str__", &__str__< ::SireVol::NullGrid > ); NullGrid_exposer.def( "__repr__", &__str__< ::SireVol::NullGrid > ); NullGrid_exposer.def( "__len__", &__len_count< ::SireVol::NullGrid > ); } }
void register_MultiFixed_class(){ { //::SireMaths::MultiFixed typedef bp::class_< SireMaths::MultiFixed > MultiFixed_exposer_t; MultiFixed_exposer_t MultiFixed_exposer = MultiFixed_exposer_t( "MultiFixed", "This class provides a vector of fixed point numbers which\nis built to complement MultiFloat. The number of fixed point\nnumbers in the vector is equal to the number of floats in MultiFloat.\n\nNote that this is a 64bit balanced fixed point representation,\ni.e. 32bits of precision are available both before and after\nthe decimal point (so about 9 significant figures on both sides,\nnote that the minus sign takes one of the bits before the decimal point).\n\nNote also that there are no functions that let you retrieve\nindividual fixed point numbers from this vector. Fixed point\nnumbers will automatically be converted tofrom doubles when\nreturned to the user.\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor - all of the elements are set to zero") ); bp::scope MultiFixed_scope( MultiFixed_exposer ); MultiFixed_exposer.def( bp::init< double >(( bp::arg("value") ), "Construct such that all elements are equal to value") ); MultiFixed_exposer.def( bp::init< double const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from the passed array. If size is greater than MultiFixed::size()\nthen an error will be raised. If size is less than MultiFixed::size() then\nthis vector will be padded with zeroes") ); MultiFixed_exposer.def( bp::init< QVector< double > const & >(( bp::arg("array") ), "Construct from the passed array. If size is greater than MultiFixed::size()\nthen an error will be raised. If size is less than MultiFixed::size() then\nthis vector will be padded with zeroes") ); MultiFixed_exposer.def( bp::init< SireMaths::MultiFloat const & >(( bp::arg("value") ), "Construct from the passed MultiFloat") ); MultiFixed_exposer.def( bp::init< SireMaths::MultiFixed const & >(( bp::arg("other") ), "Copy constructor") ); { //::SireMaths::MultiFixed::compareEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareEqual_function_type)( ::SireMaths::MultiFixed const & ) const; compareEqual_function_type compareEqual_function_value( &::SireMaths::MultiFixed::compareEqual ); MultiFixed_exposer.def( "compareEqual" , compareEqual_function_value , ( bp::arg("other") ) , "Compare each element of the two vectors. Return 0x00000000000000000 if\nthe element is not equal, 0x1111111111111111 if they are" ); } { //::SireMaths::MultiFixed::compareGreater typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreater_function_type)( ::SireMaths::MultiFixed const & ) const; compareGreater_function_type compareGreater_function_value( &::SireMaths::MultiFixed::compareGreater ); MultiFixed_exposer.def( "compareGreater" , compareGreater_function_value , ( bp::arg("other") ) , "Compare each element for greater" ); } { //::SireMaths::MultiFixed::compareGreaterEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreaterEqual_function_type)( ::SireMaths::MultiFixed const & ) const; compareGreaterEqual_function_type compareGreaterEqual_function_value( &::SireMaths::MultiFixed::compareGreaterEqual ); MultiFixed_exposer.def( "compareGreaterEqual" , compareGreaterEqual_function_value , ( bp::arg("other") ) , "Compare each element for greater or equal" ); } { //::SireMaths::MultiFixed::compareLess typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLess_function_type)( ::SireMaths::MultiFixed const & ) const; compareLess_function_type compareLess_function_value( &::SireMaths::MultiFixed::compareLess ); MultiFixed_exposer.def( "compareLess" , compareLess_function_value , ( bp::arg("other") ) , "Compare each element for less" ); } { //::SireMaths::MultiFixed::compareLessEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLessEqual_function_type)( ::SireMaths::MultiFixed const & ) const; compareLessEqual_function_type compareLessEqual_function_value( &::SireMaths::MultiFixed::compareLessEqual ); MultiFixed_exposer.def( "compareLessEqual" , compareLessEqual_function_value , ( bp::arg("other") ) , "Compare each element for less or equal" ); } { //::SireMaths::MultiFixed::compareNotEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareNotEqual_function_type)( ::SireMaths::MultiFixed const & ) const; compareNotEqual_function_type compareNotEqual_function_value( &::SireMaths::MultiFixed::compareNotEqual ); MultiFixed_exposer.def( "compareNotEqual" , compareNotEqual_function_value , ( bp::arg("other") ) , "Compare each element for inequality" ); } { //::SireMaths::MultiFixed::count typedef int ( *count_function_type )( ); count_function_type count_function_value( &::SireMaths::MultiFixed::count ); MultiFixed_exposer.def( "count" , count_function_value , "Return the number of elements in the vector" ); } { //::SireMaths::MultiFixed::fromArray typedef ::QVector< SireMaths::MultiFixed > ( *fromArray_function_type )( ::QVector< double > const & ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiFixed::fromArray ); MultiFixed_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array") ) , "Convert the passed array of doubles to an array of MultiFixed values.\nNote that the array may be returned padded with zeroes" ); } { //::SireMaths::MultiFixed::get typedef double ( ::SireMaths::MultiFixed::*get_function_type)( int ) const; get_function_type get_function_value( &::SireMaths::MultiFixed::get ); MultiFixed_exposer.def( "get" , get_function_value , ( bp::arg("i") ) , "Return the value of the ith element of the vector" ); } { //::SireMaths::MultiFixed::logicalAnd typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAnd_function_type)( ::SireMaths::MultiFixed const & ) const; logicalAnd_function_type logicalAnd_function_value( &::SireMaths::MultiFixed::logicalAnd ); MultiFixed_exposer.def( "logicalAnd" , logicalAnd_function_value , ( bp::arg("other") ) , "Logical bitwise and operator" ); } { //::SireMaths::MultiFixed::logicalAndNot typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAndNot_function_type)( ::SireMaths::MultiFixed const & ) const; logicalAndNot_function_type logicalAndNot_function_value( &::SireMaths::MultiFixed::logicalAndNot ); MultiFixed_exposer.def( "logicalAndNot" , logicalAndNot_function_value , ( bp::arg("other") ) , "Logical bitwise and not" ); } { //::SireMaths::MultiFixed::logicalNot typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalNot_function_type)( ) const; logicalNot_function_type logicalNot_function_value( &::SireMaths::MultiFixed::logicalNot ); MultiFixed_exposer.def( "logicalNot" , logicalNot_function_value , "Logical bitwise not operator" ); } { //::SireMaths::MultiFixed::logicalOr typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalOr_function_type)( ::SireMaths::MultiFixed const & ) const; logicalOr_function_type logicalOr_function_value( &::SireMaths::MultiFixed::logicalOr ); MultiFixed_exposer.def( "logicalOr" , logicalOr_function_value , ( bp::arg("other") ) , "Logical bitwise or" ); } { //::SireMaths::MultiFixed::logicalXor typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalXor_function_type)( ::SireMaths::MultiFixed const & ) const; logicalXor_function_type logicalXor_function_value( &::SireMaths::MultiFixed::logicalXor ); MultiFixed_exposer.def( "logicalXor" , logicalXor_function_value , ( bp::arg("other") ) , "Logical bitwise xor" ); } { //::SireMaths::MultiFixed::max typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*max_function_type)( ::SireMaths::MultiFixed const & ) const; max_function_type max_function_value( &::SireMaths::MultiFixed::max ); MultiFixed_exposer.def( "max" , max_function_value , ( bp::arg("other") ) , "Return the max of this vector with other" ); } { //::SireMaths::MultiFixed::min typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*min_function_type)( ::SireMaths::MultiFixed const & ) const; min_function_type min_function_value( &::SireMaths::MultiFixed::min ); MultiFixed_exposer.def( "min" , min_function_value , ( bp::arg("other") ) , "Return the min of this vector with other" ); } { //::SireMaths::MultiFixed::multiplyAdd typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*multiplyAdd_function_type)( ::SireMaths::MultiFixed const &,::SireMaths::MultiFixed const & ) ; multiplyAdd_function_type multiplyAdd_function_value( &::SireMaths::MultiFixed::multiplyAdd ); MultiFixed_exposer.def( "multiplyAdd" , multiplyAdd_function_value , ( bp::arg("val0"), bp::arg("val1") ) , bp::return_self< >() , "Multiply val0 and val1 and add it onto this vector" ); } MultiFixed_exposer.def( !bp::self ); MultiFixed_exposer.def( bp::self != bp::self ); MultiFixed_exposer.def( bp::self & bp::self ); MultiFixed_exposer.def( bp::self * bp::self ); MultiFixed_exposer.def( bp::self + bp::self ); MultiFixed_exposer.def( -bp::self ); MultiFixed_exposer.def( bp::self - bp::self ); MultiFixed_exposer.def( bp::self / bp::self ); MultiFixed_exposer.def( bp::self < bp::self ); MultiFixed_exposer.def( bp::self <= bp::self ); { //::SireMaths::MultiFixed::operator= typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*assign_function_type)( ::SireMaths::MultiFixed const & ) ; assign_function_type assign_function_value( &::SireMaths::MultiFixed::operator= ); MultiFixed_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } MultiFixed_exposer.def( bp::self == bp::self ); MultiFixed_exposer.def( bp::self > bp::self ); MultiFixed_exposer.def( bp::self >= bp::self ); { //::SireMaths::MultiFixed::operator[] typedef double ( ::SireMaths::MultiFixed::*__getitem___function_type)( int ) const; __getitem___function_type __getitem___function_value( &::SireMaths::MultiFixed::operator[] ); MultiFixed_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) , "" ); } MultiFixed_exposer.def( bp::self ^ bp::self ); MultiFixed_exposer.def( bp::self | bp::self ); { //::SireMaths::MultiFixed::reciprocal typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*reciprocal_function_type)( ) const; reciprocal_function_type reciprocal_function_value( &::SireMaths::MultiFixed::reciprocal ); MultiFixed_exposer.def( "reciprocal" , reciprocal_function_value , "Return the reciprocal of this number" ); } { //::SireMaths::MultiFixed::rotate typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rotate_function_type)( ) const; rotate_function_type rotate_function_value( &::SireMaths::MultiFixed::rotate ); MultiFixed_exposer.def( "rotate" , rotate_function_value , "Rotate this vector in the same direction as MultiFloat::rotate()" ); } { //::SireMaths::MultiFixed::rsqrt typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rsqrt_function_type)( ) const; rsqrt_function_type rsqrt_function_value( &::SireMaths::MultiFixed::rsqrt ); MultiFixed_exposer.def( "rsqrt" , rsqrt_function_value , "Return the reciprocal square root of this number" ); } { //::SireMaths::MultiFixed::set typedef void ( ::SireMaths::MultiFixed::*set_function_type)( int,double ) ; set_function_type set_function_value( &::SireMaths::MultiFixed::set ); MultiFixed_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("value") ) , "Set the ith element of this vector to value" ); } { //::SireMaths::MultiFixed::size typedef int ( *size_function_type )( ); size_function_type size_function_value( &::SireMaths::MultiFixed::size ); MultiFixed_exposer.def( "size" , size_function_value , "Return the number of elements in the vector" ); } { //::SireMaths::MultiFixed::sqrt typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*sqrt_function_type)( ) const; sqrt_function_type sqrt_function_value( &::SireMaths::MultiFixed::sqrt ); MultiFixed_exposer.def( "sqrt" , sqrt_function_value , "Return the square root of this number" ); } { //::SireMaths::MultiFixed::sum typedef double ( ::SireMaths::MultiFixed::*sum_function_type)( ) const; sum_function_type sum_function_value( &::SireMaths::MultiFixed::sum ); MultiFixed_exposer.def( "sum" , sum_function_value , "Return the sum of all of the elements of this vector" ); } { //::SireMaths::MultiFixed::toArray typedef ::QVector< double > ( *toArray_function_type )( ::QVector< SireMaths::MultiFixed > const & ); toArray_function_type toArray_function_value( &::SireMaths::MultiFixed::toArray ); MultiFixed_exposer.def( "toArray" , toArray_function_value , ( bp::arg("array") ) , "Return convert the passed MultiFixed array back into an array of doubles" ); } { //::SireMaths::MultiFixed::toBinaryString typedef ::QString ( ::SireMaths::MultiFixed::*toBinaryString_function_type)( ) const; toBinaryString_function_type toBinaryString_function_value( &::SireMaths::MultiFixed::toBinaryString ); MultiFixed_exposer.def( "toBinaryString" , toBinaryString_function_value , "" ); } { //::SireMaths::MultiFixed::toString typedef ::QString ( ::SireMaths::MultiFixed::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMaths::MultiFixed::toString ); MultiFixed_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMaths::MultiFixed::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::MultiFixed::typeName ); MultiFixed_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMaths::MultiFixed::what typedef char const * ( ::SireMaths::MultiFixed::*what_function_type)( ) const; what_function_type what_function_value( &::SireMaths::MultiFixed::what ); MultiFixed_exposer.def( "what" , what_function_value , "" ); } MultiFixed_exposer.staticmethod( "count" ); MultiFixed_exposer.staticmethod( "fromArray" ); MultiFixed_exposer.staticmethod( "size" ); MultiFixed_exposer.staticmethod( "toArray" ); MultiFixed_exposer.staticmethod( "typeName" ); MultiFixed_exposer.def( "__copy__", &__copy__); MultiFixed_exposer.def( "__deepcopy__", &__copy__); MultiFixed_exposer.def( "clone", &__copy__); MultiFixed_exposer.def( "__str__", &__str__< ::SireMaths::MultiFixed > ); MultiFixed_exposer.def( "__repr__", &__str__< ::SireMaths::MultiFixed > ); MultiFixed_exposer.def( "__len__", &__len_size< ::SireMaths::MultiFixed > ); } }
void register_AtomCoords_class(){ { //::SireMol::AtomProperty< SireMaths::Vector > typedef bp::class_< SireMol::AtomProperty< SireMaths::Vector >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomCoords_exposer_t; AtomCoords_exposer_t AtomCoords_exposer = AtomCoords_exposer_t( "AtomCoords", bp::init< >() ); bp::scope AtomCoords_scope( AtomCoords_exposer ); AtomCoords_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) ); AtomCoords_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") )) ); AtomCoords_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgroups") )) ); AtomCoords_exposer.def( bp::init< SireMol::AtomProperty< SireMaths::Vector > const & >(( bp::arg("other") )) ); { //::SireMol::AtomProperty< SireMaths::Vector >::array typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireVol::CoordGroupArray const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*array_function_type )( ) const; array_function_type array_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::array ); AtomCoords_exposer.def( "array" , array_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assertCanConvert_function_type )( ::QVariant const & ) const; assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert ); AtomCoords_exposer.def( "assertCanConvert" , assertCanConvert_function_value , ( bp::arg("value") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::assignFrom typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assignFrom_function_type )( ::SireMol::AtomProperty< QVariant > const & ) ; assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assignFrom ); AtomCoords_exposer.def( "assignFrom" , assignFrom_function_value , ( bp::arg("values") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::at typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGIdx ) const; at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at ); AtomCoords_exposer.def( "at" , at_function_value , ( bp::arg("cgidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::at typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGAtomIdx const & ) const; at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at ); AtomCoords_exposer.def( "at" , at_function_value , ( bp::arg("cgatomidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::canConvert typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*canConvert_function_type )( ::QVariant const & ) const; canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::canConvert ); AtomCoords_exposer.def( "canConvert" , canConvert_function_value , ( bp::arg("value") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame ); AtomCoords_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("from_frame"), bp::arg("to_frame") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ; changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame ); AtomCoords_exposer.def( "changeFrame" , changeFrame_function_value , ( bp::arg("cgidx"), bp::arg("from_frame"), bp::arg("to_frame") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const & ) ; copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom ); AtomCoords_exposer.def( "copyFrom" , copyFrom_function_value , ( bp::arg("values") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const &,::SireMol::AtomSelection const & ) ; copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom ); AtomCoords_exposer.def( "copyFrom" , copyFrom_function_value , ( bp::arg("values"), bp::arg("selection") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::count typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*count_function_type )( ) const; count_function_type count_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::count ); AtomCoords_exposer.def( "count" , count_function_value ); } { //::SireMol::AtomProperty< SireMaths::Vector >::divide typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divide_function_type )( ::QVector< SireMol::AtomSelection > const & ) const; divide_function_type divide_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divide ); AtomCoords_exposer.def( "divide" , divide_function_value , ( bp::arg("beads") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divideByResidue_function_type )( ::SireMol::MoleculeInfoData const & ) const; divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue ); AtomCoords_exposer.def( "divideByResidue" , divideByResidue_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::fromVariant typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< SireMaths::Vector > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & ); fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::fromVariant ); AtomCoords_exposer.def( "fromVariant" , fromVariant_function_value , ( bp::arg("variant") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::get typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGIdx ) const; get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get ); AtomCoords_exposer.def( "get" , get_function_value , ( bp::arg("cgidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::get typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGAtomIdx const & ) const; get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get ); AtomCoords_exposer.def( "get" , get_function_value , ( bp::arg("cgatomidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const; isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith ); AtomCoords_exposer.def( "isCompatibleWith" , isCompatibleWith_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto ); AtomCoords_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("axes") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const & ) ; mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto ); AtomCoords_exposer.def( "mapInto" , mapInto_function_value , ( bp::arg("cgidx"), bp::arg("axes") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::merge typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*merge_function_type )( ::SireMol::MoleculeInfoData const & ) const; merge_function_type merge_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::merge ); AtomCoords_exposer.def( "merge" , merge_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ) const; nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms ); AtomCoords_exposer.def( "nAtoms" , nAtoms_function_value ); } { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ::SireMol::CGIdx ) const; nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms ); AtomCoords_exposer.def( "nAtoms" , nAtoms_function_value , ( bp::arg("cgidx") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nCutGroups_function_type )( ) const; nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups ); AtomCoords_exposer.def( "nCutGroups" , nCutGroups_function_value ); } AtomCoords_exposer.def( bp::self != bp::self ); { //::SireMol::AtomProperty< SireMaths::Vector >::operator= typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*assign_function_type )( ::SireMol::AtomProperty< SireMaths::Vector > const & ) ; assign_function_type assign_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator= ); AtomCoords_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } AtomCoords_exposer.def( bp::self == bp::self ); { //::SireMol::AtomProperty< SireMaths::Vector >::operator[] typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGIdx ) const; __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] ); AtomCoords_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("cgidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::operator[] typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGAtomIdx const & ) const; __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] ); AtomCoords_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("cgatomidx") ) , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::rotate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate ); AtomCoords_exposer.def( "rotate" , rotate_function_value , ( bp::arg("quat"), bp::arg("point") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::rotate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate ); AtomCoords_exposer.def( "rotate" , rotate_function_value , ( bp::arg("rotmat"), bp::arg("point") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::rotate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate ); AtomCoords_exposer.def( "rotate" , rotate_function_value , ( bp::arg("cgidx"), bp::arg("quat"), bp::arg("point") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::rotate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ; rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate ); AtomCoords_exposer.def( "rotate" , rotate_function_value , ( bp::arg("cgidx"), bp::arg("rotmat"), bp::arg("point") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::set typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGAtomIdx const &,::SireMaths::Vector const & ) ; set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set ); AtomCoords_exposer.def( "set" , set_function_value , ( bp::arg("cgatomidx"), bp::arg("value") ) , bp::return_self< >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::set typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::QVector< SireMaths::Vector > const & ) ; set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set ); AtomCoords_exposer.def( "set" , set_function_value , ( bp::arg("cgidx"), bp::arg("values") ) , bp::return_self< >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::set typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::SireVol::CoordGroup const & ) ; set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set ); AtomCoords_exposer.def( "set" , set_function_value , ( bp::arg("cgidx"), bp::arg("cgroup") ) , bp::return_self< >() ); } { //::SireMol::AtomProperty< SireMaths::Vector >::size typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*size_function_type )( ) const; size_function_type size_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::size ); AtomCoords_exposer.def( "size" , size_function_value ); } { //::SireMol::AtomProperty< SireMaths::Vector >::toVariant typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVariant_function_type )( ) const; toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVariant ); AtomCoords_exposer.def( "toVariant" , toVariant_function_value ); } { //::SireMol::AtomProperty< SireMaths::Vector >::toVector typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ) const; toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector ); AtomCoords_exposer.def( "toVector" , toVector_function_value ); } { //::SireMol::AtomProperty< SireMaths::Vector >::toVector typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ::SireMol::AtomSelection const & ) const; toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector ); AtomCoords_exposer.def( "toVector" , toVector_function_value , ( bp::arg("selection") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::transform typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform ); AtomCoords_exposer.def( "transform" , transform_function_value , ( bp::arg("t") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::transform typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMol::CGIdx,::SireMaths::Transform const & ) ; transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform ); AtomCoords_exposer.def( "transform" , transform_function_value , ( bp::arg("cgidx"), bp::arg("t") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::translate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate ); AtomCoords_exposer.def( "translate" , translate_function_value , ( bp::arg("delta") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::translate typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMol::CGIdx,::SireMaths::Vector const & ) ; translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate ); AtomCoords_exposer.def( "translate" , translate_function_value , ( bp::arg("cgidx"), bp::arg("delta") ) ); } { //::SireMol::AtomProperty< SireMaths::Vector >::typeName typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t; typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::typeName ); AtomCoords_exposer.def( "typeName" , typeName_function_value ); } AtomCoords_exposer.staticmethod( "fromVariant" ); AtomCoords_exposer.staticmethod( "typeName" ); AtomCoords_exposer.def( "__copy__", &__copy__); AtomCoords_exposer.def( "__deepcopy__", &__copy__); AtomCoords_exposer.def( "clone", &__copy__); AtomCoords_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomCoords_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); AtomCoords_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > ); AtomCoords_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > ); AtomCoords_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<SireMaths::Vector> > ); } }
void register_MultiFixed_class(){ { //::SireMaths::MultiFixed typedef bp::class_< SireMaths::MultiFixed > MultiFixed_exposer_t; MultiFixed_exposer_t MultiFixed_exposer = MultiFixed_exposer_t( "MultiFixed", bp::init< >() ); bp::scope MultiFixed_scope( MultiFixed_exposer ); MultiFixed_exposer.def( bp::init< double >(( bp::arg("value") )) ); MultiFixed_exposer.def( bp::init< double const *, int >(( bp::arg("array"), bp::arg("size") )) ); MultiFixed_exposer.def( bp::init< QVector< double > const & >(( bp::arg("array") )) ); MultiFixed_exposer.def( bp::init< SireMaths::MultiFloat const & >(( bp::arg("value") )) ); MultiFixed_exposer.def( bp::init< SireMaths::MultiFixed const & >(( bp::arg("other") )) ); { //::SireMaths::MultiFixed::compareEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareEqual_function_type )( ::SireMaths::MultiFixed const & ) const; compareEqual_function_type compareEqual_function_value( &::SireMaths::MultiFixed::compareEqual ); MultiFixed_exposer.def( "compareEqual" , compareEqual_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::compareGreater typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreater_function_type )( ::SireMaths::MultiFixed const & ) const; compareGreater_function_type compareGreater_function_value( &::SireMaths::MultiFixed::compareGreater ); MultiFixed_exposer.def( "compareGreater" , compareGreater_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::compareGreaterEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreaterEqual_function_type )( ::SireMaths::MultiFixed const & ) const; compareGreaterEqual_function_type compareGreaterEqual_function_value( &::SireMaths::MultiFixed::compareGreaterEqual ); MultiFixed_exposer.def( "compareGreaterEqual" , compareGreaterEqual_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::compareLess typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLess_function_type )( ::SireMaths::MultiFixed const & ) const; compareLess_function_type compareLess_function_value( &::SireMaths::MultiFixed::compareLess ); MultiFixed_exposer.def( "compareLess" , compareLess_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::compareLessEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLessEqual_function_type )( ::SireMaths::MultiFixed const & ) const; compareLessEqual_function_type compareLessEqual_function_value( &::SireMaths::MultiFixed::compareLessEqual ); MultiFixed_exposer.def( "compareLessEqual" , compareLessEqual_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::compareNotEqual typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareNotEqual_function_type )( ::SireMaths::MultiFixed const & ) const; compareNotEqual_function_type compareNotEqual_function_value( &::SireMaths::MultiFixed::compareNotEqual ); MultiFixed_exposer.def( "compareNotEqual" , compareNotEqual_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::count typedef int ( *count_function_type )( ); count_function_type count_function_value( &::SireMaths::MultiFixed::count ); MultiFixed_exposer.def( "count" , count_function_value ); } { //::SireMaths::MultiFixed::fromArray typedef ::QVector< SireMaths::MultiFixed > ( *fromArray_function_type )( ::QVector< double > const & ); fromArray_function_type fromArray_function_value( &::SireMaths::MultiFixed::fromArray ); MultiFixed_exposer.def( "fromArray" , fromArray_function_value , ( bp::arg("array") ) ); } { //::SireMaths::MultiFixed::get typedef double ( ::SireMaths::MultiFixed::*get_function_type )( int ) const; get_function_type get_function_value( &::SireMaths::MultiFixed::get ); MultiFixed_exposer.def( "get" , get_function_value , ( bp::arg("i") ) ); } { //::SireMaths::MultiFixed::logicalAnd typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAnd_function_type )( ::SireMaths::MultiFixed const & ) const; logicalAnd_function_type logicalAnd_function_value( &::SireMaths::MultiFixed::logicalAnd ); MultiFixed_exposer.def( "logicalAnd" , logicalAnd_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::logicalAndNot typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAndNot_function_type )( ::SireMaths::MultiFixed const & ) const; logicalAndNot_function_type logicalAndNot_function_value( &::SireMaths::MultiFixed::logicalAndNot ); MultiFixed_exposer.def( "logicalAndNot" , logicalAndNot_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::logicalNot typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalNot_function_type )( ) const; logicalNot_function_type logicalNot_function_value( &::SireMaths::MultiFixed::logicalNot ); MultiFixed_exposer.def( "logicalNot" , logicalNot_function_value ); } { //::SireMaths::MultiFixed::logicalOr typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalOr_function_type )( ::SireMaths::MultiFixed const & ) const; logicalOr_function_type logicalOr_function_value( &::SireMaths::MultiFixed::logicalOr ); MultiFixed_exposer.def( "logicalOr" , logicalOr_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::logicalXor typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalXor_function_type )( ::SireMaths::MultiFixed const & ) const; logicalXor_function_type logicalXor_function_value( &::SireMaths::MultiFixed::logicalXor ); MultiFixed_exposer.def( "logicalXor" , logicalXor_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::max typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*max_function_type )( ::SireMaths::MultiFixed const & ) const; max_function_type max_function_value( &::SireMaths::MultiFixed::max ); MultiFixed_exposer.def( "max" , max_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::min typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*min_function_type )( ::SireMaths::MultiFixed const & ) const; min_function_type min_function_value( &::SireMaths::MultiFixed::min ); MultiFixed_exposer.def( "min" , min_function_value , ( bp::arg("other") ) ); } { //::SireMaths::MultiFixed::multiplyAdd typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*multiplyAdd_function_type )( ::SireMaths::MultiFixed const &,::SireMaths::MultiFixed const & ) ; multiplyAdd_function_type multiplyAdd_function_value( &::SireMaths::MultiFixed::multiplyAdd ); MultiFixed_exposer.def( "multiplyAdd" , multiplyAdd_function_value , ( bp::arg("val0"), bp::arg("val1") ) , bp::return_self< >() ); } MultiFixed_exposer.def( !bp::self ); MultiFixed_exposer.def( bp::self != bp::self ); MultiFixed_exposer.def( bp::self & bp::self ); MultiFixed_exposer.def( bp::self * bp::self ); MultiFixed_exposer.def( bp::self + bp::self ); MultiFixed_exposer.def( -bp::self ); MultiFixed_exposer.def( bp::self - bp::self ); MultiFixed_exposer.def( bp::self / bp::self ); MultiFixed_exposer.def( bp::self < bp::self ); MultiFixed_exposer.def( bp::self <= bp::self ); { //::SireMaths::MultiFixed::operator= typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*assign_function_type )( ::SireMaths::MultiFixed const & ) ; assign_function_type assign_function_value( &::SireMaths::MultiFixed::operator= ); MultiFixed_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } MultiFixed_exposer.def( bp::self == bp::self ); MultiFixed_exposer.def( bp::self > bp::self ); MultiFixed_exposer.def( bp::self >= bp::self ); { //::SireMaths::MultiFixed::operator[] typedef double ( ::SireMaths::MultiFixed::*__getitem___function_type )( int ) const; __getitem___function_type __getitem___function_value( &::SireMaths::MultiFixed::operator[] ); MultiFixed_exposer.def( "__getitem__" , __getitem___function_value , ( bp::arg("i") ) ); } MultiFixed_exposer.def( bp::self ^ bp::self ); MultiFixed_exposer.def( bp::self | bp::self ); { //::SireMaths::MultiFixed::reciprocal typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*reciprocal_function_type )( ) const; reciprocal_function_type reciprocal_function_value( &::SireMaths::MultiFixed::reciprocal ); MultiFixed_exposer.def( "reciprocal" , reciprocal_function_value ); } { //::SireMaths::MultiFixed::rotate typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rotate_function_type )( ) const; rotate_function_type rotate_function_value( &::SireMaths::MultiFixed::rotate ); MultiFixed_exposer.def( "rotate" , rotate_function_value ); } { //::SireMaths::MultiFixed::rsqrt typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rsqrt_function_type )( ) const; rsqrt_function_type rsqrt_function_value( &::SireMaths::MultiFixed::rsqrt ); MultiFixed_exposer.def( "rsqrt" , rsqrt_function_value ); } { //::SireMaths::MultiFixed::set typedef void ( ::SireMaths::MultiFixed::*set_function_type )( int,double ) ; set_function_type set_function_value( &::SireMaths::MultiFixed::set ); MultiFixed_exposer.def( "set" , set_function_value , ( bp::arg("i"), bp::arg("value") ) ); } { //::SireMaths::MultiFixed::size typedef int ( *size_function_type )( ); size_function_type size_function_value( &::SireMaths::MultiFixed::size ); MultiFixed_exposer.def( "size" , size_function_value ); } { //::SireMaths::MultiFixed::sqrt typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*sqrt_function_type )( ) const; sqrt_function_type sqrt_function_value( &::SireMaths::MultiFixed::sqrt ); MultiFixed_exposer.def( "sqrt" , sqrt_function_value ); } { //::SireMaths::MultiFixed::sum typedef double ( ::SireMaths::MultiFixed::*sum_function_type )( ) const; sum_function_type sum_function_value( &::SireMaths::MultiFixed::sum ); MultiFixed_exposer.def( "sum" , sum_function_value ); } { //::SireMaths::MultiFixed::toArray typedef ::QVector< double > ( *toArray_function_type )( ::QVector< SireMaths::MultiFixed > const & ); toArray_function_type toArray_function_value( &::SireMaths::MultiFixed::toArray ); MultiFixed_exposer.def( "toArray" , toArray_function_value , ( bp::arg("array") ) ); } { //::SireMaths::MultiFixed::toBinaryString typedef ::QString ( ::SireMaths::MultiFixed::*toBinaryString_function_type )( ) const; toBinaryString_function_type toBinaryString_function_value( &::SireMaths::MultiFixed::toBinaryString ); MultiFixed_exposer.def( "toBinaryString" , toBinaryString_function_value ); } { //::SireMaths::MultiFixed::toString typedef ::QString ( ::SireMaths::MultiFixed::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMaths::MultiFixed::toString ); MultiFixed_exposer.def( "toString" , toString_function_value ); } { //::SireMaths::MultiFixed::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMaths::MultiFixed::typeName ); MultiFixed_exposer.def( "typeName" , typeName_function_value ); } { //::SireMaths::MultiFixed::what typedef char const * ( ::SireMaths::MultiFixed::*what_function_type )( ) const; what_function_type what_function_value( &::SireMaths::MultiFixed::what ); MultiFixed_exposer.def( "what" , what_function_value ); } MultiFixed_exposer.staticmethod( "count" ); MultiFixed_exposer.staticmethod( "fromArray" ); MultiFixed_exposer.staticmethod( "size" ); MultiFixed_exposer.staticmethod( "toArray" ); MultiFixed_exposer.staticmethod( "typeName" ); MultiFixed_exposer.def( "__copy__", &__copy__); MultiFixed_exposer.def( "__deepcopy__", &__copy__); MultiFixed_exposer.def( "clone", &__copy__); MultiFixed_exposer.def( "__str__", &__str__< ::SireMaths::MultiFixed > ); MultiFixed_exposer.def( "__repr__", &__str__< ::SireMaths::MultiFixed > ); MultiFixed_exposer.def( "__len__", &__len_size< ::SireMaths::MultiFixed > ); } }