void register_SegStringProperty_class(){
{ //::SireMol::SegProperty< QString >
typedef bp::class_< SireMol::SegProperty< QString >, bp::bases< SireMol::SegProp, SireMol::MolViewProperty, SireBase::Property > > SegStringProperty_exposer_t;
SegStringProperty_exposer_t SegStringProperty_exposer = SegStringProperty_exposer_t( "SegStringProperty", bp::init< >() );
bp::scope SegStringProperty_scope( SegStringProperty_exposer );
SegStringProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
SegStringProperty_exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
SegStringProperty_exposer.def( bp::init< SireMol::SegProperty< QString > const & >(( bp::arg("other") )) );
{ //::SireMol::SegProperty< QString >::array
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QVector< QString > const & ( ::SireMol::SegProperty< QString >::*array_function_type )( ) const;
array_function_type array_function_value( &::SireMol::SegProperty< QString >::array );
SegStringProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::assertCanConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assertCanConvert_function_type )( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::SegProperty< QString >::assertCanConvert );
SegStringProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::assignFrom
typedef SireMol::SegProperty< QString > exported_class_t;
typedef void ( ::SireMol::SegProperty< QString >::*assignFrom_function_type )( ::SireMol::SegProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::SegProperty< QString >::assignFrom );
SegStringProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::at
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*at_function_type )( ::SireMol::SegIdx const & ) const;
at_function_type at_function_value( &::SireMol::SegProperty< QString >::at );
SegStringProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::canConvert
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*canConvert_function_type )( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::SegProperty< QString >::canConvert );
SegStringProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::SegProperty< QString >::count
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::SegProperty< QString >::count );
SegStringProperty_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::SegProperty< QString >::fromVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > ( *fromVariant_function_type )( ::SireMol::SegProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::SegProperty< QString >::fromVariant );
SegStringProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::SegProperty< QString >::get
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*get_function_type )( ::SireMol::SegIdx const & ) const;
get_function_type get_function_value( &::SireMol::SegProperty< QString >::get );
SegStringProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::isCompatibleWith
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::SegProperty< QString >::isCompatibleWith );
SegStringProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::SegProperty< QString >::isEmpty
typedef SireMol::SegProperty< QString > exported_class_t;
typedef bool ( ::SireMol::SegProperty< QString >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::SegProperty< QString >::isEmpty );
SegStringProperty_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::SegProperty< QString >::nSegments
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*nSegments_function_type )( ) const;
nSegments_function_type nSegments_function_value( &::SireMol::SegProperty< QString >::nSegments );
SegStringProperty_exposer.def(
"nSegments"
, nSegments_function_value );
}
SegStringProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::SegProperty< QString >::operator=
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*assign_function_type )( ::SireMol::SegProperty< QString > const & ) ;
assign_function_type assign_function_value( &::SireMol::SegProperty< QString >::operator= );
SegStringProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
SegStringProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::SegProperty< QString >::operator[]
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString const & ( ::SireMol::SegProperty< QString >::*__getitem___function_type )( ::SireMol::SegIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::SegProperty< QString >::operator[] );
SegStringProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("segidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::SegProperty< QString >::set
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QString > & ( ::SireMol::SegProperty< QString >::*set_function_type )( ::SireMol::SegIdx,::QString const & ) ;
set_function_type set_function_value( &::SireMol::SegProperty< QString >::set );
SegStringProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("segidx"), bp::arg("value") )
, bp::return_self< >() );
}
{ //::SireMol::SegProperty< QString >::size
typedef SireMol::SegProperty< QString > exported_class_t;
typedef int ( ::SireMol::SegProperty< QString >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMol::SegProperty< QString >::size );
SegStringProperty_exposer.def(
"size"
, size_function_value );
}
{ //::SireMol::SegProperty< QString >::toString
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::QString ( ::SireMol::SegProperty< QString >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::SegProperty< QString >::toString );
SegStringProperty_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::SegProperty< QString >::toVariant
typedef SireMol::SegProperty< QString > exported_class_t;
typedef ::SireMol::SegProperty< QVariant > ( ::SireMol::SegProperty< QString >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::SegProperty< QString >::toVariant );
SegStringProperty_exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireMol::SegProperty< QString >::typeName
typedef SireMol::SegProperty< QString > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::SegProperty< QString >::typeName );
SegStringProperty_exposer.def(
"typeName"
, typeName_function_value );
}
SegStringProperty_exposer.staticmethod( "fromVariant" );
SegStringProperty_exposer.staticmethod( "typeName" );
SegStringProperty_exposer.def( "__copy__", &__copy__);
SegStringProperty_exposer.def( "__deepcopy__", &__copy__);
SegStringProperty_exposer.def( "clone", &__copy__);
SegStringProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SegProperty<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
SegStringProperty_exposer.def( "__str__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__repr__", &__str__< ::SireMol::SegProperty<QString> > );
SegStringProperty_exposer.def( "__len__", &__len_size< ::SireMol::SegProperty<QString> > );
}
}
void register_AtomFloatProperty_class(){
{ //::SireMol::AtomProperty< double >
typedef bp::class_< SireMol::AtomProperty< double >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomFloatProperty_exposer_t;
AtomFloatProperty_exposer_t AtomFloatProperty_exposer = AtomFloatProperty_exposer_t( "AtomFloatProperty", "", bp::init< >("") );
bp::scope AtomFloatProperty_scope( AtomFloatProperty_exposer );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const &, double const & >(( bp::arg("molinfo"), bp::arg("default_value") ), "") );
AtomFloatProperty_exposer.def( bp::init< double const & >(( bp::arg("value") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireBase::PackedArray2D< double > const & >(( bp::arg("values") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::AtomProperty< double > const & >(( bp::arg("other") ), "") );
{ //::SireMol::AtomProperty< double >::array
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double > const & ( ::SireMol::AtomProperty< double >::*array_function_type)( ) const;
array_function_type array_function_value( &::SireMol::AtomProperty< double >::array );
AtomFloatProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::assertCanConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assertCanConvert_function_type)( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< double >::assertCanConvert );
AtomFloatProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::assignFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assignFrom_function_type)( ::SireMol::AtomProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< double >::assignFrom );
AtomFloatProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGIdx ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGAtomIdx const & ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::canConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*canConvert_function_type)( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< double >::canConvert );
AtomFloatProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const &,::SireMol::AtomSelection const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values"), bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::count
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMol::AtomProperty< double >::count );
AtomFloatProperty_exposer.def(
"count"
, count_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::divide
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divide_function_type)( ::QVector< SireMol::AtomSelection > const & ) const;
divide_function_type divide_function_value( &::SireMol::AtomProperty< double >::divide );
AtomFloatProperty_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("beads") )
, "" );
}
{ //::SireMol::AtomProperty< double >::divideByResidue
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divideByResidue_function_type)( ::SireMol::MoleculeInfoData const & ) const;
divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< double >::divideByResidue );
AtomFloatProperty_exposer.def(
"divideByResidue"
, divideByResidue_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::fromVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< double >::fromVariant );
AtomFloatProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") )
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGIdx ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGAtomIdx const & ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfo const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isEmpty
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::AtomProperty< double >::isEmpty );
AtomFloatProperty_exposer.def(
"isEmpty"
, isEmpty_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::matchToSelection
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( ::SireMol::AtomProperty< double >::*matchToSelection_function_type)( ::SireMol::AtomSelection const & ) const;
matchToSelection_function_type matchToSelection_function_value( &::SireMol::AtomProperty< double >::matchToSelection );
AtomFloatProperty_exposer.def(
"matchToSelection"
, matchToSelection_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::merge
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*merge_function_type)( ::SireMol::MoleculeInfoData const & ) const;
merge_function_type merge_function_value( &::SireMol::AtomProperty< double >::merge );
AtomFloatProperty_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ::SireMol::CGIdx ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, ( bp::arg("cgidx") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nCutGroups
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nCutGroups_function_type)( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< double >::nCutGroups );
AtomFloatProperty_exposer.def(
"nCutGroups"
, nCutGroups_function_value
, "" );
}
AtomFloatProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomProperty< double >::operator=
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*assign_function_type)( ::SireMol::AtomProperty< double > const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomProperty< double >::operator= );
AtomFloatProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AtomFloatProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGIdx ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGAtomIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGAtomIdx const &,double const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgatomidx"), bp::arg("value") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGIdx,::QVector< double > const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("values") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::size
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMol::AtomProperty< double >::size );
AtomFloatProperty_exposer.def(
"size"
, size_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toString
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QString ( ::SireMol::AtomProperty< double >::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::AtomProperty< double >::toString );
AtomFloatProperty_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< double >::*toVariant_function_type)( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< double >::toVariant );
AtomFloatProperty_exposer.def(
"toVariant"
, toVariant_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::typeName
typedef SireMol::AtomProperty< double > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomProperty< double >::typeName );
AtomFloatProperty_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
AtomFloatProperty_exposer.staticmethod( "fromVariant" );
AtomFloatProperty_exposer.staticmethod( "typeName" );
AtomFloatProperty_exposer.def( "__copy__", &__copy__);
AtomFloatProperty_exposer.def( "__deepcopy__", &__copy__);
AtomFloatProperty_exposer.def( "clone", &__copy__);
AtomFloatProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<double> > );
}
}
void register_TrigArray2D_double__class(){
{ //::SireBase::TrigArray2D< double >
typedef bp::class_< SireBase::TrigArray2D< double >, bp::bases< SireBase::TrigArray2DBase > > TrigArray2D_double__exposer_t;
TrigArray2D_double__exposer_t TrigArray2D_double__exposer = TrigArray2D_double__exposer_t( "TrigArray2D_double_", bp::init< >() );
bp::scope TrigArray2D_double__scope( TrigArray2D_double__exposer );
TrigArray2D_double__exposer.def( bp::init< int >(( bp::arg("dimension") )) );
TrigArray2D_double__exposer.def( bp::init< int, double const & >(( bp::arg("dimension"), bp::arg("default_value") )) );
TrigArray2D_double__exposer.def( bp::init< SireBase::TrigArray2D< double > const & >(( bp::arg("other") )) );
{ //::SireBase::TrigArray2D< double >::at
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*at_function_type )( int,int ) const;
at_function_type at_function_value( &::SireBase::TrigArray2D< double >::at );
TrigArray2D_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::TrigArray2D< double >::get
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*get_function_type )( int,int ) const;
get_function_type get_function_value( &::SireBase::TrigArray2D< double >::get );
TrigArray2D_double__exposer.def(
"get"
, get_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
TrigArray2D_double__exposer.def( bp::self != bp::self );
{ //::SireBase::TrigArray2D< double >::operator()
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef double const & ( ::SireBase::TrigArray2D< double >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireBase::TrigArray2D< double >::operator() );
TrigArray2D_double__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::TrigArray2D< double >::operator=
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::SireBase::TrigArray2D< double > & ( ::SireBase::TrigArray2D< double >::*assign_function_type )( ::SireBase::TrigArray2D< double > const & ) ;
assign_function_type assign_function_value( &::SireBase::TrigArray2D< double >::operator= );
TrigArray2D_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
TrigArray2D_double__exposer.def( bp::self == bp::self );
{ //::SireBase::TrigArray2D< double >::redimension
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*redimension_function_type )( int ) ;
redimension_function_type redimension_function_value( &::SireBase::TrigArray2D< double >::redimension );
TrigArray2D_double__exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("dimension") ) );
}
{ //::SireBase::TrigArray2D< double >::set
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*set_function_type )( int,int,double const & ) ;
set_function_type set_function_value( &::SireBase::TrigArray2D< double >::set );
TrigArray2D_double__exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
}
{ //::SireBase::TrigArray2D< double >::setAll
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef void ( ::SireBase::TrigArray2D< double >::*setAll_function_type )( double const & ) ;
setAll_function_type setAll_function_value( &::SireBase::TrigArray2D< double >::setAll );
TrigArray2D_double__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::TrigArray2D< double >::toString
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::QString ( ::SireBase::TrigArray2D< double >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::TrigArray2D< double >::toString );
TrigArray2D_double__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::TrigArray2D< double >::transpose
typedef SireBase::TrigArray2D< double > exported_class_t;
typedef ::SireBase::TrigArray2D< double > ( ::SireBase::TrigArray2D< double >::*transpose_function_type )( ) const;
transpose_function_type transpose_function_value( &::SireBase::TrigArray2D< double >::transpose );
TrigArray2D_double__exposer.def(
"transpose"
, transpose_function_value );
}
TrigArray2D_double__exposer.def( "__copy__", &__copy__);
TrigArray2D_double__exposer.def( "__deepcopy__", &__copy__);
TrigArray2D_double__exposer.def( "clone", &__copy__);
TrigArray2D_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::TrigArray2D<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TrigArray2D_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::TrigArray2D<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
TrigArray2D_double__exposer.def( "__str__", &__str__< ::SireBase::TrigArray2D<double> > );
TrigArray2D_double__exposer.def( "__repr__", &__str__< ::SireBase::TrigArray2D<double> > );
TrigArray2D_double__exposer.def( "__len__", &__len_size< ::SireBase::TrigArray2D<double> > );
}
}
void register_CLJBoxes_class(){
{ //::SireMM::CLJBoxes
typedef bp::class_< SireMM::CLJBoxes > CLJBoxes_exposer_t;
CLJBoxes_exposer_t CLJBoxes_exposer = CLJBoxes_exposer_t( "CLJBoxes", bp::init< >() );
bp::scope CLJBoxes_scope( CLJBoxes_exposer );
CLJBoxes_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const & >(( bp::arg("atoms") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const & >(( bp::arg("atoms0"), bp::arg("atoms1") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms0"), bp::arg("atoms1"), bp::arg("box_size") )) );
CLJBoxes_exposer.def( bp::init< SireMM::CLJBoxes const & >(( bp::arg("other") )) );
{ //::SireMM::CLJBoxes::add
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*add_function_type )( ::SireMM::CLJAtoms const & ) ;
add_function_type add_function_value( &::SireMM::CLJBoxes::add );
CLJBoxes_exposer.def(
"add"
, add_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::at
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*at_function_type )( ::SireMM::CLJBoxIndex const & ) const;
at_function_type at_function_value( &::SireMM::CLJBoxes::at );
CLJBoxes_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value );
}
{ //::SireMM::CLJBoxes::atoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
CLJBoxes_exposer.def(
"atoms"
, atoms_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( int ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxAt
typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMaths::Vector const & ) const;
boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
CLJBoxes_exposer.def(
"boxAt"
, boxAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxDimensions
typedef ::QVector< SireVol::AABox > ( ::SireMM::CLJBoxes::*boxDimensions_function_type )( ) const;
boxDimensions_function_type boxDimensions_function_value( &::SireMM::CLJBoxes::boxDimensions );
CLJBoxes_exposer.def(
"boxDimensions"
, boxDimensions_function_value );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( int ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("index") ) );
}
{ //::SireMM::CLJBoxes::boxDimensionsAt
typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMaths::Vector const & ) const;
boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
CLJBoxes_exposer.def(
"boxDimensionsAt"
, boxDimensionsAt_function_value
, ( bp::arg("coords") ) );
}
{ //::SireMM::CLJBoxes::boxes
typedef ::QVector< SireMM::CLJBox > ( ::SireMM::CLJBoxes::*boxes_function_type )( ) const;
boxes_function_type boxes_function_value( &::SireMM::CLJBoxes::boxes );
CLJBoxes_exposer.def(
"boxes"
, boxes_function_value );
}
{ //::SireMM::CLJBoxes::get
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*get_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
get_function_type get_function_value( &::SireMM::CLJBoxes::get );
CLJBoxes_exposer.def(
"get"
, get_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1") ) );
}
{ //::SireMM::CLJBoxes::getDistance
typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const &,::quint32,::quint32,::quint32 ) const;
getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
CLJBoxes_exposer.def(
"getDistance"
, getDistance_function_value
, ( bp::arg("space"), bp::arg("box0"), bp::arg("box1"), bp::arg("nx"), bp::arg("ny"), bp::arg("nz") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const & );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1") ) );
}
{ //::SireMM::CLJBoxes::getDistances
typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
CLJBoxes_exposer.def(
"getDistances"
, getDistances_function_value
, ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
}
{ //::SireMM::CLJBoxes::getitem
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*getitem_function_type )( ::SireMM::CLJBoxIndex const & ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJBoxes::getitem );
CLJBoxes_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::isEmpty
typedef bool ( ::SireMM::CLJBoxes::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJBoxes::isEmpty );
CLJBoxes_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMM::CLJBoxes::length
typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJBoxes::*length_function_type )( ) const;
length_function_type length_function_value( &::SireMM::CLJBoxes::length );
CLJBoxes_exposer.def(
"length"
, length_function_value );
}
{ //::SireMM::CLJBoxes::nAtoms
typedef int ( ::SireMM::CLJBoxes::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMM::CLJBoxes::nAtoms );
CLJBoxes_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMM::CLJBoxes::nOccupiedBoxes
typedef int ( ::SireMM::CLJBoxes::*nOccupiedBoxes_function_type )( ) const;
nOccupiedBoxes_function_type nOccupiedBoxes_function_value( &::SireMM::CLJBoxes::nOccupiedBoxes );
CLJBoxes_exposer.def(
"nOccupiedBoxes"
, nOccupiedBoxes_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxIndicies
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*occupiedBoxIndicies_function_type )( ) const;
occupiedBoxIndicies_function_type occupiedBoxIndicies_function_value( &::SireMM::CLJBoxes::occupiedBoxIndicies );
CLJBoxes_exposer.def(
"occupiedBoxIndicies"
, occupiedBoxIndicies_function_value );
}
{ //::SireMM::CLJBoxes::occupiedBoxes
typedef ::QVector< SireMM::CLJBoxPtr > const & ( ::SireMM::CLJBoxes::*occupiedBoxes_function_type )( ) const;
occupiedBoxes_function_type occupiedBoxes_function_value( &::SireMM::CLJBoxes::occupiedBoxes );
CLJBoxes_exposer.def(
"occupiedBoxes"
, occupiedBoxes_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
CLJBoxes_exposer.def( bp::self != bp::self );
CLJBoxes_exposer.def( bp::self + bp::self );
{ //::SireMM::CLJBoxes::operator=
typedef ::SireMM::CLJBoxes & ( ::SireMM::CLJBoxes::*assign_function_type )( ::SireMM::CLJBoxes const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJBoxes::operator= );
CLJBoxes_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
CLJBoxes_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJBoxes::operator[]
typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*__getitem___function_type )( ::SireMM::CLJBoxIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJBoxes::operator[] );
CLJBoxes_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireMM::CLJBoxes::remove
typedef void ( ::SireMM::CLJBoxes::*remove_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
remove_function_type remove_function_value( &::SireMM::CLJBoxes::remove );
CLJBoxes_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::squeeze
typedef ::SireMM::CLJBoxes ( ::SireMM::CLJBoxes::*squeeze_function_type )( ) const;
squeeze_function_type squeeze_function_value( &::SireMM::CLJBoxes::squeeze );
CLJBoxes_exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireMM::CLJBoxes::take
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*take_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
take_function_type take_function_value( &::SireMM::CLJBoxes::take );
CLJBoxes_exposer.def(
"take"
, take_function_value
, ( bp::arg("atoms") ) );
}
{ //::SireMM::CLJBoxes::toString
typedef ::QString ( ::SireMM::CLJBoxes::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::CLJBoxes::toString );
CLJBoxes_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::CLJBoxes::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::CLJBoxes::typeName );
CLJBoxes_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::CLJBoxes::what
typedef char const * ( ::SireMM::CLJBoxes::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMM::CLJBoxes::what );
CLJBoxes_exposer.def(
"what"
, what_function_value );
}
CLJBoxes_exposer.staticmethod( "getDistances" );
CLJBoxes_exposer.staticmethod( "typeName" );
CLJBoxes_exposer.def( "__copy__", &__copy__);
CLJBoxes_exposer.def( "__deepcopy__", &__copy__);
CLJBoxes_exposer.def( "clone", &__copy__);
CLJBoxes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJBoxes >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CLJBoxes_exposer.def( "__str__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__repr__", &__str__< ::SireMM::CLJBoxes > );
CLJBoxes_exposer.def( "__getitem__", &::SireMM::CLJBoxes::getitem );
}
}
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_Array2D_SireMaths_AccumulatorPtr__class(){
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >
typedef bp::class_< SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >, bp::bases< SireBase::Array2DBase > > Array2D_SireMaths_AccumulatorPtr__exposer_t;
Array2D_SireMaths_AccumulatorPtr__exposer_t Array2D_SireMaths_AccumulatorPtr__exposer = Array2D_SireMaths_AccumulatorPtr__exposer_t( "Array2D_SireMaths_AccumulatorPtr_", bp::init< >() );
bp::scope Array2D_SireMaths_AccumulatorPtr__scope( Array2D_SireMaths_AccumulatorPtr__exposer );
Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< int, int >(( bp::arg("nrows"), bp::arg("ncolumns") )) );
Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< int, int, SireBase::PropPtr< SireMaths::Accumulator > const & >(( bp::arg("nrows"), bp::arg("ncolumns"), bp::arg("default_value") )) );
Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > const & >(( bp::arg("other") )) );
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::at
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*at_function_type )( int,int ) const;
at_function_type at_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::at );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::get
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*get_function_type )( int,int ) const;
get_function_type get_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::get );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"get"
, get_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::self != bp::self );
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator()
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator() );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator=
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*assign_function_type )( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > const & ) ;
assign_function_type assign_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator= );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::self == bp::self );
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::redimension
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*redimension_function_type )( int,int ) ;
redimension_function_type redimension_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::redimension );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("nrows"), bp::arg("ncolumns") ) );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::set
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*set_function_type )( int,int,::SireBase::PropPtr< SireMaths::Accumulator > const & ) ;
set_function_type set_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::set );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::setAll
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*setAll_function_type )( ::SireBase::PropPtr< SireMaths::Accumulator > const & ) ;
setAll_function_type setAll_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::setAll );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::toString
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::QString ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::toString );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::transpose
typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
typedef ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*transpose_function_type )( ) const;
transpose_function_type transpose_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::transpose );
Array2D_SireMaths_AccumulatorPtr__exposer.def(
"transpose"
, transpose_function_value );
}
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__copy__", &__copy__);
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__deepcopy__", &__copy__);
Array2D_SireMaths_AccumulatorPtr__exposer.def( "clone", &__copy__);
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__str__", &__str__< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > > );
Array2D_SireMaths_AccumulatorPtr__exposer.def( "__repr__", &__str__< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > > );
}
}
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 > );
}
}
