void register_CoordGroupArray_class(){
{ //::SireVol::CoordGroupArray
typedef bp::class_< SireVol::CoordGroupArray > CoordGroupArray_exposer_t;
CoordGroupArray_exposer_t CoordGroupArray_exposer = CoordGroupArray_exposer_t( "CoordGroupArray", "This class holds an array of CoordGroups. While you could\nof course just use a QVector<CoordGroup>, this array\noptimises the memory layout of all of the CoordGroups\nso that they all lie contiguously along the same piece\nof memory (and indeed, all of the AABoxes are grouped\ntogether, while all of the coordinates are grouped together).\n\nThe memory packing means that this array is much more\nlimited than a QVector<CoordGroup>, i.e. you cant\nadd or remove CoordGroups from the array, and you cant\ndo anything to the contained CoordGroups except for\nchange their coordinates.\n\nThis class is really meant to be used as a fast container\nthat allow rapid iteration over all of the contained\nCoordGroups coordinates\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope CoordGroupArray_scope( CoordGroupArray_exposer );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") ), "Construct an array that holds just the passed CoordGroup") );
CoordGroupArray_exposer.def( bp::init< QVector< QVector< SireMaths::Vector > > const & >(( bp::arg("points") ), "Construct from a double-vector") );
CoordGroupArray_exposer.def( bp::init< QVector< SireVol::CoordGroup > const & >(( bp::arg("cgroups") ), "Construct from an array of CoordGroups") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const &, SireVol::CoordGroupArray const & >(( bp::arg("array0"), bp::arg("array1") ), "Construct from a pair of CoordGroupArrays") );
CoordGroupArray_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireVol::CoordGroupArray::aaBox
typedef ::SireVol::AABox ( ::SireVol::CoordGroupArray::*aaBox_function_type)( ) const;
aaBox_function_type aaBox_function_value( &::SireVol::CoordGroupArray::aaBox );
CoordGroupArray_exposer.def(
"aaBox"
, aaBox_function_value
, "Return an AABox that complete encompasses all of the CoordGroups\nin this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroup const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroup") )
, "Append the passed CoordGroup onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::append
typedef void ( ::SireVol::CoordGroupArray::*append_function_type)( ::SireVol::CoordGroupArray const & ) ;
append_function_type append_function_value( &::SireVol::CoordGroupArray::append );
CoordGroupArray_exposer.def(
"append"
, append_function_value
, ( bp::arg("cgroups") )
, "Append the passed CoordGroups onto the end of this array" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordGroup
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordGroup_function_type)( ::quint32 ) const;
assertValidCoordGroup_function_type assertValidCoordGroup_function_value( &::SireVol::CoordGroupArray::assertValidCoordGroup );
CoordGroupArray_exposer.def(
"assertValidCoordGroup"
, assertValidCoordGroup_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidCoordinate
typedef void ( ::SireVol::CoordGroupArray::*assertValidCoordinate_function_type)( ::quint32 ) const;
assertValidCoordinate_function_type assertValidCoordinate_function_value( &::SireVol::CoordGroupArray::assertValidCoordinate );
CoordGroupArray_exposer.def(
"assertValidCoordinate"
, assertValidCoordinate_function_value
, ( bp::arg("i") )
, "Assert that the index i points a valid coordinate\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::assertValidIndex
typedef void ( ::SireVol::CoordGroupArray::*assertValidIndex_function_type)( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireVol::CoordGroupArray::assertValidIndex );
CoordGroupArray_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") )
, "Assert that the index i points to a valid CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::at
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*at_function_type)( ::quint32 ) const;
at_function_type at_function_value( &::SireVol::CoordGroupArray::at );
CoordGroupArray_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return a reference to the ith CoordGroup\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in this array from the\ncoordinate frame from_frame to the coordinate frame to_frame" );
}
{ //::SireVol::CoordGroupArray::changeFrame
typedef void ( ::SireVol::CoordGroupArray::*changeFrame_function_type)( ::quint32,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireVol::CoordGroupArray::changeFrame );
CoordGroupArray_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("i"), bp::arg("from_frame"), bp::arg("to_frame") )
, "Change all of the coordinates in the ith CoordGroup from\nthe coordinate frame from_frame to the coordinate frame\nto_frame\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::count
typedef int ( ::SireVol::CoordGroupArray::*count_function_type)( ) const;
count_function_type count_function_value( &::SireVol::CoordGroupArray::count );
CoordGroupArray_exposer.def(
"count"
, count_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::isEmpty
typedef bool ( ::SireVol::CoordGroupArray::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::CoordGroupArray::isEmpty );
CoordGroupArray_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this array is empty" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") )
, "Map all of the coordinates in this array into the coordinate\nframe represented by axes" );
}
{ //::SireVol::CoordGroupArray::mapInto
typedef void ( ::SireVol::CoordGroupArray::*mapInto_function_type)( ::quint32,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireVol::CoordGroupArray::mapInto );
CoordGroupArray_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("i"), bp::arg("axes") )
, "Map all of the coordinates of the CoordGroup at index i\ninto the coordinate frame represented by axes\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::merge
typedef ::SireVol::CoordGroup ( ::SireVol::CoordGroupArray::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireVol::CoordGroupArray::merge );
CoordGroupArray_exposer.def(
"merge"
, merge_function_value
, "Merge this array of CoordGroups back into a single CoordGroup" );
}
{ //::SireVol::CoordGroupArray::nCoordGroups
typedef int ( ::SireVol::CoordGroupArray::*nCoordGroups_function_type)( ) const;
nCoordGroups_function_type nCoordGroups_function_value( &::SireVol::CoordGroupArray::nCoordGroups );
CoordGroupArray_exposer.def(
"nCoordGroups"
, nCoordGroups_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::nCoords
typedef int ( ::SireVol::CoordGroupArray::*nCoords_function_type)( ) const;
nCoords_function_type nCoords_function_value( &::SireVol::CoordGroupArray::nCoords );
CoordGroupArray_exposer.def(
"nCoords"
, nCoords_function_value
, "Return the number of coordinates in this array" );
}
CoordGroupArray_exposer.def( bp::self != bp::self );
{ //::SireVol::CoordGroupArray::operator=
typedef ::SireVol::CoordGroupArray & ( ::SireVol::CoordGroupArray::*assign_function_type)( ::SireVol::CoordGroupArray const & ) ;
assign_function_type assign_function_value( &::SireVol::CoordGroupArray::operator= );
CoordGroupArray_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CoordGroupArray_exposer.def( bp::self == bp::self );
{ //::SireVol::CoordGroupArray::operator[]
typedef ::SireVol::CoordGroup const & ( ::SireVol::CoordGroupArray::*__getitem___function_type)( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireVol::CoordGroupArray::operator[] );
CoordGroupArray_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32 ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, "Remove the ith CoordGroup from the array" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::quint32,int ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") )
, "Remove count CoordGroups from the array, starting with the ith CoordGroup" );
}
{ //::SireVol::CoordGroupArray::remove
typedef void ( ::SireVol::CoordGroupArray::*remove_function_type)( ::QVarLengthArray< unsigned int, 256 > const & ) ;
remove_function_type remove_function_value( &::SireVol::CoordGroupArray::remove );
CoordGroupArray_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("idxs") )
, "Remove the specified CoordGroups from the array" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in this array using the quaternion\nquat around the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of coordinates in this array using the matrix rotmat\nabout the point point" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("quat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe quaternion quat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::rotate
typedef void ( ::SireVol::CoordGroupArray::*rotate_function_type)( ::quint32,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireVol::CoordGroupArray::rotate );
CoordGroupArray_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("i"), bp::arg("rotmat"), bp::arg("point") )
, "Rotate all of the coordinates in the CoordGroup at index i using\nthe matrix rotmat about the point point\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::size
typedef int ( ::SireVol::CoordGroupArray::*size_function_type)( ) const;
size_function_type size_function_value( &::SireVol::CoordGroupArray::size );
CoordGroupArray_exposer.def(
"size"
, size_function_value
, "Return the number of CoordGroups in this array" );
}
{ //::SireVol::CoordGroupArray::toString
typedef ::QString ( ::SireVol::CoordGroupArray::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireVol::CoordGroupArray::toString );
CoordGroupArray_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this array" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") )
, "Transform all of coordinates in this array using the transformation t" );
}
{ //::SireVol::CoordGroupArray::transform
typedef void ( ::SireVol::CoordGroupArray::*transform_function_type)( ::quint32,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireVol::CoordGroupArray::transform );
CoordGroupArray_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("i"), bp::arg("t") )
, "Transform all of the coordinates in the CoordGroup at index i using\nthe transformation t\nThrow: SireError::invalid_index\n" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") )
, "Translate all of the coordinates in this array by delta" );
}
{ //::SireVol::CoordGroupArray::translate
typedef void ( ::SireVol::CoordGroupArray::*translate_function_type)( ::quint32,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireVol::CoordGroupArray::translate );
CoordGroupArray_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("i"), bp::arg("delta") )
, "Translate all of the coordinates in the ith CoordGroup by delta" );
}
{ //::SireVol::CoordGroupArray::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::CoordGroupArray::typeName );
CoordGroupArray_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireVol::CoordGroup const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("cgroup") )
, "Update the CoordGroup at index i so that it is equal to cgroup. Note\nthat cgroup must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::QVector< SireMaths::Vector > const & ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords") )
, "Update the CoordGroup at index i so that it has coordinates coords\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::update
typedef void ( ::SireVol::CoordGroupArray::*update_function_type)( ::quint32,::SireMaths::Vector const *,int ) ;
update_function_type update_function_value( &::SireVol::CoordGroupArray::update );
CoordGroupArray_exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("coords"), bp::arg("ncoords") )
, "Update the CoordGroup at index i so that it has coordinates coords\n(there are ncoords coordinates in this array)\nThere must contain the same number of coordinates as the existing\nCoordGroup at this index\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireVol::CoordGroupArray::what
typedef char const * ( ::SireVol::CoordGroupArray::*what_function_type)( ) const;
what_function_type what_function_value( &::SireVol::CoordGroupArray::what );
CoordGroupArray_exposer.def(
"what"
, what_function_value
, "" );
}
CoordGroupArray_exposer.staticmethod( "typeName" );
CoordGroupArray_exposer.def( "__copy__", &__copy__);
CoordGroupArray_exposer.def( "__deepcopy__", &__copy__);
CoordGroupArray_exposer.def( "clone", &__copy__);
CoordGroupArray_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::CoordGroupArray >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
CoordGroupArray_exposer.def( "__str__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__repr__", &__str__< ::SireVol::CoordGroupArray > );
CoordGroupArray_exposer.def( "__len__", &__len_size< ::SireVol::CoordGroupArray > );
}
}
void register_PackedArray2D_int_Array_class(){
{ //::SireBase::detail::PackedArray2D_Array< int >
typedef bp::class_< SireBase::detail::PackedArray2D_Array< int > > PackedArray2D_int_Array_exposer_t;
PackedArray2D_int_Array_exposer_t PackedArray2D_int_Array_exposer = PackedArray2D_int_Array_exposer_t( "PackedArray2D_int_Array", bp::init< >() );
bp::scope PackedArray2D_int_Array_scope( PackedArray2D_int_Array_exposer );
PackedArray2D_int_Array_exposer.def( bp::init< quint32 >(( bp::arg("sz") )) );
PackedArray2D_int_Array_exposer.def( bp::init< quint32, int const & >(( bp::arg("sz"), bp::arg("value") )) );
PackedArray2D_int_Array_exposer.def( bp::init< QVector< int > const & >(( bp::arg("values") )) );
PackedArray2D_int_Array_exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< int > const & >(( bp::arg("other") )) );
{ //::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*assertValidIndex_function_type )( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::detail::PackedArray2D_Array< int >::assertValidIndex );
PackedArray2D_int_Array_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::at
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*at_function_type )( ::quint32 ) const;
at_function_type at_function_value( &::SireBase::detail::PackedArray2D_Array< int >::at );
PackedArray2D_int_Array_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::count
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::detail::PackedArray2D_Array< int >::count );
PackedArray2D_int_Array_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::isEmpty
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef bool ( ::SireBase::detail::PackedArray2D_Array< int >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::detail::PackedArray2D_Array< int >::isEmpty );
PackedArray2D_int_Array_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::nValues
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*nValues_function_type )( ) const;
nValues_function_type nValues_function_value( &::SireBase::detail::PackedArray2D_Array< int >::nValues );
PackedArray2D_int_Array_exposer.def(
"nValues"
, nValues_function_value );
}
PackedArray2D_int_Array_exposer.def( bp::self != bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator=
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= );
PackedArray2D_int_Array_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PackedArray2D_int_Array_exposer.def( bp::self == bp::self );
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::operator[]
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ;
__getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );
PackedArray2D_int_Array_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::size
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size );
PackedArray2D_int_Array_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toQVector
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )( ) const;
toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector );
PackedArray2D_int_Array_exposer.def(
"toQVector"
, toQVector_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::toString
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString );
PackedArray2D_int_Array_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::detail::PackedArray2D_Array< int >::update
typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;
typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;
update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update );
PackedArray2D_int_Array_exposer.def(
"update"
, update_function_value
, ( bp::arg("other") ) );
}
PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__);
PackedArray2D_int_Array_exposer.def( "clone", &__copy__);
PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );
PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > );
}
}
void register_NVector_class(){
{ //::SireMaths::NVector
typedef bp::class_< SireMaths::NVector > NVector_exposer_t;
NVector_exposer_t NVector_exposer = NVector_exposer_t( "NVector", bp::init< >() );
bp::scope NVector_scope( NVector_exposer );
NVector_exposer.def( bp::init< int >(( bp::arg("nrows") )) );
NVector_exposer.def( bp::init< int, double >(( bp::arg("nrows"), bp::arg("initial_value") )) );
NVector_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("vector") )) );
NVector_exposer.def( bp::init< QVector< double > const & >(( bp::arg("vector") )) );
NVector_exposer.def( bp::init< SireMaths::NVector const & >(( bp::arg("vector") )) );
{ //::SireMaths::NVector::assertNColumns
typedef void ( ::SireMaths::NVector::*assertNColumns_function_type )( int ) const;
assertNColumns_function_type assertNColumns_function_value( &::SireMaths::NVector::assertNColumns );
NVector_exposer.def(
"assertNColumns"
, assertNColumns_function_value
, ( bp::arg("ncolumns") ) );
}
{ //::SireMaths::NVector::assertNRows
typedef void ( ::SireMaths::NVector::*assertNRows_function_type )( int ) const;
assertNRows_function_type assertNRows_function_value( &::SireMaths::NVector::assertNRows );
NVector_exposer.def(
"assertNRows"
, assertNRows_function_value
, ( bp::arg("nrows") ) );
}
{ //::SireMaths::NVector::assertValidIndex
typedef void ( ::SireMaths::NVector::*assertValidIndex_function_type )( int ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::NVector::assertValidIndex );
NVector_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireMaths::NVector::assertValidIndex
typedef void ( ::SireMaths::NVector::*assertValidIndex_function_type )( int,int ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::NVector::assertValidIndex );
NVector_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireMaths::NVector::count
typedef int ( ::SireMaths::NVector::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMaths::NVector::count );
NVector_exposer.def(
"count"
, count_function_value );
}
{ //::SireMaths::NVector::cross
typedef ::SireMaths::NVector ( ::SireMaths::NVector::*cross_function_type )( ::SireMaths::NVector const & ) const;
cross_function_type cross_function_value( &::SireMaths::NVector::cross );
NVector_exposer.def(
"cross"
, cross_function_value
, ( bp::arg("other") ) );
}
{ //::SireMaths::NVector::dot
typedef double ( ::SireMaths::NVector::*dot_function_type )( ::SireMaths::NVector const & ) const;
dot_function_type dot_function_value( &::SireMaths::NVector::dot );
NVector_exposer.def(
"dot"
, dot_function_value
, ( bp::arg("other") ) );
}
{ //::SireMaths::NVector::isZero
typedef bool ( ::SireMaths::NVector::*isZero_function_type )( ) const;
isZero_function_type isZero_function_value( &::SireMaths::NVector::isZero );
NVector_exposer.def(
"isZero"
, isZero_function_value );
}
{ //::SireMaths::NVector::length
typedef double ( ::SireMaths::NVector::*length_function_type )( ) const;
length_function_type length_function_value( &::SireMaths::NVector::length );
NVector_exposer.def(
"length"
, length_function_value );
}
{ //::SireMaths::NVector::length2
typedef double ( ::SireMaths::NVector::*length2_function_type )( ) const;
length2_function_type length2_function_value( &::SireMaths::NVector::length2 );
NVector_exposer.def(
"length2"
, length2_function_value );
}
{ //::SireMaths::NVector::nColumns
typedef int ( ::SireMaths::NVector::*nColumns_function_type )( ) const;
nColumns_function_type nColumns_function_value( &::SireMaths::NVector::nColumns );
NVector_exposer.def(
"nColumns"
, nColumns_function_value );
}
{ //::SireMaths::NVector::nRows
typedef int ( ::SireMaths::NVector::*nRows_function_type )( ) const;
nRows_function_type nRows_function_value( &::SireMaths::NVector::nRows );
NVector_exposer.def(
"nRows"
, nRows_function_value );
}
{ //::SireMaths::NVector::normalise
typedef ::SireMaths::NVector ( ::SireMaths::NVector::*normalise_function_type )( ) const;
normalise_function_type normalise_function_value( &::SireMaths::NVector::normalise );
NVector_exposer.def(
"normalise"
, normalise_function_value );
}
NVector_exposer.def( bp::self != bp::self );
{ //::SireMaths::NVector::operator()
typedef double const & ( ::SireMaths::NVector::*__call___function_type )( int ) const;
__call___function_type __call___function_value( &::SireMaths::NVector::operator() );
NVector_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::NVector::operator()
typedef double const & ( ::SireMaths::NVector::*__call___function_type )( int,int ) const;
__call___function_type __call___function_value( &::SireMaths::NVector::operator() );
NVector_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
NVector_exposer.def( bp::self * bp::other< double >() );
NVector_exposer.def( bp::self + bp::self );
NVector_exposer.def( -bp::self );
NVector_exposer.def( bp::self - bp::self );
NVector_exposer.def( bp::self / bp::other< double >() );
{ //::SireMaths::NVector::operator=
typedef ::SireMaths::NVector & ( ::SireMaths::NVector::*assign_function_type )( ::SireMaths::NVector const & ) ;
assign_function_type assign_function_value( &::SireMaths::NVector::operator= );
NVector_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NVector_exposer.def( bp::self == bp::self );
{ //::SireMaths::NVector::operator[]
typedef double & ( ::SireMaths::NVector::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireMaths::NVector::operator[] );
NVector_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireMaths::NVector::operator[]
typedef double const & ( ::SireMaths::NVector::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::NVector::operator[] );
NVector_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::NVector::set
typedef void ( ::SireMaths::NVector::*set_function_type )( int,double ) ;
set_function_type set_function_value( &::SireMaths::NVector::set );
NVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireMaths::NVector::set
typedef void ( ::SireMaths::NVector::*set_function_type )( int,int,double ) ;
set_function_type set_function_value( &::SireMaths::NVector::set );
NVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
}
{ //::SireMaths::NVector::setAll
typedef void ( ::SireMaths::NVector::*setAll_function_type )( double ) ;
setAll_function_type setAll_function_value( &::SireMaths::NVector::setAll );
NVector_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("value") ) );
}
{ //::SireMaths::NVector::size
typedef int ( ::SireMaths::NVector::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMaths::NVector::size );
NVector_exposer.def(
"size"
, size_function_value );
}
{ //::SireMaths::NVector::sum
typedef double ( ::SireMaths::NVector::*sum_function_type )( ) const;
sum_function_type sum_function_value( &::SireMaths::NVector::sum );
NVector_exposer.def(
"sum"
, sum_function_value );
}
{ //::SireMaths::NVector::toString
typedef ::QString ( ::SireMaths::NVector::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::NVector::toString );
NVector_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::NVector::transpose
typedef ::SireMaths::NMatrix ( ::SireMaths::NVector::*transpose_function_type )( ) const;
transpose_function_type transpose_function_value( &::SireMaths::NVector::transpose );
NVector_exposer.def(
"transpose"
, transpose_function_value );
}
{ //::SireMaths::NVector::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::NVector::typeName );
NVector_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::NVector::what
typedef char const * ( ::SireMaths::NVector::*what_function_type )( ) const;
what_function_type what_function_value( &::SireMaths::NVector::what );
NVector_exposer.def(
"what"
, what_function_value );
}
NVector_exposer.staticmethod( "typeName" );
NVector_exposer.def( bp::other< double >() * bp::self );
NVector_exposer.def( "__copy__", &__copy__);
NVector_exposer.def( "__deepcopy__", &__copy__);
NVector_exposer.def( "clone", &__copy__);
NVector_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::NVector >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NVector_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::NVector >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NVector_exposer.def( "__str__", &__str__< ::SireMaths::NVector > );
NVector_exposer.def( "__repr__", &__str__< ::SireMaths::NVector > );
NVector_exposer.def( "__len__", &__len_size< ::SireMaths::NVector > );
}
}
void register_N4Matrix_class(){
{ //::SireMaths::N4Matrix
typedef bp::class_< SireMaths::N4Matrix > N4Matrix_exposer_t;
N4Matrix_exposer_t N4Matrix_exposer = N4Matrix_exposer_t( "N4Matrix", "This is a dense, double, general NMLK 4-dimensional matrix.\nThe data is stored as a column-major 2D matrix of column-major\n2D matricies (so each 2D sub-matrix is suitable for\nuse with Fortran BLAS or LAPACK functions). This is\ndesigned for high speed.\n\nThe data is implicitly shared (copy on write), so\ncopying a matrix is very fast.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope N4Matrix_scope( N4Matrix_exposer );
N4Matrix_exposer.def( bp::init< int, int, int, int >(( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("columns") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are not initialised") );
N4Matrix_exposer.def( bp::init< int, int, int, int, double >(( bp::arg("nbigrows"), bp::arg("nbigcolumn"), bp::arg("nrows"), bp::arg("ncolumns"), bp::arg("initial_value") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are\ninitialised to be equal to initial_value") );
N4Matrix_exposer.def( bp::init< SireMaths::NMatrix const & >(( bp::arg("matrix") ), "Construct from the passed matrix - this creates a matrix\nof dimension [1, 1, matrix.nRows(), matrix.nColumns()]") );
N4Matrix_exposer.def( bp::init< SireBase::Array2D< SireMaths::NMatrix > const & >(( bp::arg("matrix") ), "Construct from the passed Array or Matricies") );
N4Matrix_exposer.def( bp::init< QVector< QVector< QVector< QVector< double > > > > const & >(( bp::arg("matrix") ), "Construct from the passed vector of vector of vector of vectors...") );
N4Matrix_exposer.def( bp::init< SireMaths::N4Matrix const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMaths::N4Matrix::add
typedef void ( ::SireMaths::N4Matrix::*add_function_type)( int,int,::SireMaths::NMatrix const & ) ;
add_function_type add_function_value( &::SireMaths::N4Matrix::add );
N4Matrix_exposer.def(
"add"
, add_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
, "Add the contents of matrix to the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::assertNBigColumns
typedef void ( ::SireMaths::N4Matrix::*assertNBigColumns_function_type)( int ) const;
assertNBigColumns_function_type assertNBigColumns_function_value( &::SireMaths::N4Matrix::assertNBigColumns );
N4Matrix_exposer.def(
"assertNBigColumns"
, assertNBigColumns_function_value
, ( bp::arg("nbigcolumns") )
, "Assert that this matrix has nbigcolumns big columns\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::assertNBigRows
typedef void ( ::SireMaths::N4Matrix::*assertNBigRows_function_type)( int ) const;
assertNBigRows_function_type assertNBigRows_function_value( &::SireMaths::N4Matrix::assertNBigRows );
N4Matrix_exposer.def(
"assertNBigRows"
, assertNBigRows_function_value
, ( bp::arg("nbigrows") )
, "Assert that this matrix has nbigrows big rows\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::assertNColumns
typedef void ( ::SireMaths::N4Matrix::*assertNColumns_function_type)( int ) const;
assertNColumns_function_type assertNColumns_function_value( &::SireMaths::N4Matrix::assertNColumns );
N4Matrix_exposer.def(
"assertNColumns"
, assertNColumns_function_value
, ( bp::arg("ncolumns") )
, "Assert that this matrix has ncolumns columns\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::assertNRows
typedef void ( ::SireMaths::N4Matrix::*assertNRows_function_type)( int ) const;
assertNRows_function_type assertNRows_function_value( &::SireMaths::N4Matrix::assertNRows );
N4Matrix_exposer.def(
"assertNRows"
, assertNRows_function_value
, ( bp::arg("nrows") )
, "Assert that this matrix has nrows rows\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::assertValidBigColumn
typedef void ( ::SireMaths::N4Matrix::*assertValidBigColumn_function_type)( int ) const;
assertValidBigColumn_function_type assertValidBigColumn_function_value( &::SireMaths::N4Matrix::assertValidBigColumn );
N4Matrix_exposer.def(
"assertValidBigColumn"
, assertValidBigColumn_function_value
, ( bp::arg("j") )
, "Assert that there is an jth big column\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::assertValidBigRow
typedef void ( ::SireMaths::N4Matrix::*assertValidBigRow_function_type)( int ) const;
assertValidBigRow_function_type assertValidBigRow_function_value( &::SireMaths::N4Matrix::assertValidBigRow );
N4Matrix_exposer.def(
"assertValidBigRow"
, assertValidBigRow_function_value
, ( bp::arg("i") )
, "Assert that there is an ith big row\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::assertValidColumn
typedef void ( ::SireMaths::N4Matrix::*assertValidColumn_function_type)( int ) const;
assertValidColumn_function_type assertValidColumn_function_value( &::SireMaths::N4Matrix::assertValidColumn );
N4Matrix_exposer.def(
"assertValidColumn"
, assertValidColumn_function_value
, ( bp::arg("l") )
, "Assert that there is an lth column\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::assertValidIndex
typedef void ( ::SireMaths::N4Matrix::*assertValidIndex_function_type)( int,int,int,int ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::N4Matrix::assertValidIndex );
N4Matrix_exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
, "Assert that the index [i,j,k,l] is valid for this matrix\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::assertValidRow
typedef void ( ::SireMaths::N4Matrix::*assertValidRow_function_type)( int ) const;
assertValidRow_function_type assertValidRow_function_value( &::SireMaths::N4Matrix::assertValidRow );
N4Matrix_exposer.def(
"assertValidRow"
, assertValidRow_function_value
, ( bp::arg("k") )
, "Assert that there is an kth row\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::checkedOffset
typedef int ( ::SireMaths::N4Matrix::*checkedOffset_function_type)( int,int,int,int ) const;
checkedOffset_function_type checkedOffset_function_value( &::SireMaths::N4Matrix::checkedOffset );
N4Matrix_exposer.def(
"checkedOffset"
, checkedOffset_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
, "Calculate the offset in the 1D array of the value\nat index [i,j,k,l]\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::memory
typedef ::QVector< double > ( ::SireMaths::N4Matrix::*memory_function_type)( ) const;
memory_function_type memory_function_value( &::SireMaths::N4Matrix::memory );
N4Matrix_exposer.def(
"memory"
, memory_function_value
, "Return the raw QVector memory used by this matrix" );
}
{ //::SireMaths::N4Matrix::nBigColumns
typedef int ( ::SireMaths::N4Matrix::*nBigColumns_function_type)( ) const;
nBigColumns_function_type nBigColumns_function_value( &::SireMaths::N4Matrix::nBigColumns );
N4Matrix_exposer.def(
"nBigColumns"
, nBigColumns_function_value
, "Return the number of big columns in this matrix" );
}
{ //::SireMaths::N4Matrix::nBigRows
typedef int ( ::SireMaths::N4Matrix::*nBigRows_function_type)( ) const;
nBigRows_function_type nBigRows_function_value( &::SireMaths::N4Matrix::nBigRows );
N4Matrix_exposer.def(
"nBigRows"
, nBigRows_function_value
, "Return the number of big rows in this matrix" );
}
{ //::SireMaths::N4Matrix::nColumns
typedef int ( ::SireMaths::N4Matrix::*nColumns_function_type)( ) const;
nColumns_function_type nColumns_function_value( &::SireMaths::N4Matrix::nColumns );
N4Matrix_exposer.def(
"nColumns"
, nColumns_function_value
, "Return the number of columns in this matrix" );
}
{ //::SireMaths::N4Matrix::nRows
typedef int ( ::SireMaths::N4Matrix::*nRows_function_type)( ) const;
nRows_function_type nRows_function_value( &::SireMaths::N4Matrix::nRows );
N4Matrix_exposer.def(
"nRows"
, nRows_function_value
, "Return the number of rows in this matrix" );
}
{ //::SireMaths::N4Matrix::offset
typedef int ( ::SireMaths::N4Matrix::*offset_function_type)( int,int,int,int ) const;
offset_function_type offset_function_value( &::SireMaths::N4Matrix::offset );
N4Matrix_exposer.def(
"offset"
, offset_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
, "" );
}
N4Matrix_exposer.def( bp::self != bp::self );
{ //::SireMaths::N4Matrix::operator()
typedef double const & ( ::SireMaths::N4Matrix::*__call___function_type)( int,int,int,int ) const;
__call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() );
N4Matrix_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::N4Matrix::operator()
typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*__call___function_type)( int,int ) const;
__call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() );
N4Matrix_exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, "" );
}
N4Matrix_exposer.def( bp::self * bp::other< double >() );
N4Matrix_exposer.def( bp::self + bp::self );
N4Matrix_exposer.def( -bp::self );
N4Matrix_exposer.def( bp::self - bp::self );
N4Matrix_exposer.def( bp::self / bp::other< double >() );
{ //::SireMaths::N4Matrix::operator=
typedef ::SireMaths::N4Matrix & ( ::SireMaths::N4Matrix::*assign_function_type)( ::SireMaths::N4Matrix const & ) ;
assign_function_type assign_function_value( &::SireMaths::N4Matrix::operator= );
N4Matrix_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
N4Matrix_exposer.def( bp::self == bp::self );
{ //::SireMaths::N4Matrix::redimension
typedef void ( ::SireMaths::N4Matrix::*redimension_function_type)( int,int,int,int ) ;
redimension_function_type redimension_function_value( &::SireMaths::N4Matrix::redimension );
N4Matrix_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("ncolumns") )
, "Redimension this matrix to have nbigrows big rows,\nnbigcolumns big columns, nrows rows and ncolumns\ncolumns. The contents of this matrix are undefined after\nthis redimension. This function will only reallocate\nmemory if there is not enough memory allocated to store\nthe new matrix. Use this function if you want to use\nthe same piece of memory over and over again for lots\nof different size matricies - just create a matrix with\nthe maximum dimension, then call this redimension function\nwhenever you want to change. It is very fast, as it just\nupdates the internal record of the size of the matrix" );
}
{ //::SireMaths::N4Matrix::set
typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,::SireMaths::NMatrix const & ) ;
set_function_type set_function_value( &::SireMaths::N4Matrix::set );
N4Matrix_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
, "Set the view at [i,j] equal to matrix\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::set
typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,int,int,double ) ;
set_function_type set_function_value( &::SireMaths::N4Matrix::set );
N4Matrix_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l"), bp::arg("value") )
, "Set the value at [i,j,k,l] equal to value\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::setAll
typedef void ( ::SireMaths::N4Matrix::*setAll_function_type)( double ) ;
setAll_function_type setAll_function_value( &::SireMaths::N4Matrix::setAll );
N4Matrix_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("value") )
, "Set all entries in the matrix to the value value" );
}
{ //::SireMaths::N4Matrix::subtract
typedef void ( ::SireMaths::N4Matrix::*subtract_function_type)( int,int,::SireMaths::NMatrix const & ) ;
subtract_function_type subtract_function_value( &::SireMaths::N4Matrix::subtract );
N4Matrix_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
, "Subtract the contents of matrix from the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMaths::N4Matrix::toString
typedef ::QString ( ::SireMaths::N4Matrix::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::N4Matrix::toString );
N4Matrix_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this matrix" );
}
{ //::SireMaths::N4Matrix::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::N4Matrix::typeName );
N4Matrix_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMaths::N4Matrix::view
typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*view_function_type)( int,int ) const;
view_function_type view_function_value( &::SireMaths::N4Matrix::view );
N4Matrix_exposer.def(
"view"
, view_function_value
, ( bp::arg("i"), bp::arg("j") )
, "Return the sub-matrix view at [i,j,k,l]\nThrow: SireError::invalid_index\n" );
}
{ //::SireMaths::N4Matrix::what
typedef char const * ( ::SireMaths::N4Matrix::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMaths::N4Matrix::what );
N4Matrix_exposer.def(
"what"
, what_function_value
, "" );
}
N4Matrix_exposer.staticmethod( "typeName" );
N4Matrix_exposer.def( "__copy__", &__copy__);
N4Matrix_exposer.def( "__deepcopy__", &__copy__);
N4Matrix_exposer.def( "clone", &__copy__);
N4Matrix_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::N4Matrix >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
N4Matrix_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::N4Matrix >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
N4Matrix_exposer.def( "__str__", &__str__< ::SireMaths::N4Matrix > );
N4Matrix_exposer.def( "__repr__", &__str__< ::SireMaths::N4Matrix > );
}
}
void register_PackedArray2D_QString__class(){
{ //::SireBase::PackedArray2D< QString >
typedef bp::class_< SireBase::PackedArray2D< QString > > PackedArray2D_QString__exposer_t;
PackedArray2D_QString__exposer_t PackedArray2D_QString__exposer = PackedArray2D_QString__exposer_t( "PackedArray2D_QString_", bp::init< >() );
bp::scope PackedArray2D_QString__scope( PackedArray2D_QString__exposer );
PackedArray2D_QString__exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< QString > const & >(( bp::arg("array") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< SireBase::detail::PackedArray2D_Array< QString > > const & >(( bp::arg("arrays") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
PackedArray2D_QString__exposer.def( bp::init< QVector< QVector< QString > > const & >(( bp::arg("values") )) );
PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const &, SireBase::PackedArray2D< QString > const & >(( bp::arg("array0"), bp::arg("array1") )) );
PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const & >(( bp::arg("other") )) );
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("arrays") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QString > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::append
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QVector< QString > > const & ) ;
append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
PackedArray2D_QString__exposer.def(
"append"
, append_function_value
, ( bp::arg("arrays") ) );
}
{ //::SireBase::PackedArray2D< QString >::assertValidIndex
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*assertValidIndex_function_type )( ::quint32 ) const;
assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::PackedArray2D< QString >::assertValidIndex );
PackedArray2D_QString__exposer.def(
"assertValidIndex"
, assertValidIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PackedArray2D< QString >::at
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32 ) const;
at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
PackedArray2D_QString__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::at
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32,::quint32 ) const;
at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
PackedArray2D_QString__exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::count
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PackedArray2D< QString >::count );
PackedArray2D_QString__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PackedArray2D< QString >::fromVariant
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QString > ( *fromVariant_function_type )( ::SireBase::PackedArray2D< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireBase::PackedArray2D< QString >::fromVariant );
PackedArray2D_QString__exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") ) );
}
{ //::SireBase::PackedArray2D< QString >::isEmpty
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef bool ( ::SireBase::PackedArray2D< QString >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PackedArray2D< QString >::isEmpty );
PackedArray2D_QString__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nArrays
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nArrays_function_type )( ) const;
nArrays_function_type nArrays_function_value( &::SireBase::PackedArray2D< QString >::nArrays );
PackedArray2D_QString__exposer.def(
"nArrays"
, nArrays_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nValues
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ) const;
nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
PackedArray2D_QString__exposer.def(
"nValues"
, nValues_function_value );
}
{ //::SireBase::PackedArray2D< QString >::nValues
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ::quint32 ) const;
nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
PackedArray2D_QString__exposer.def(
"nValues"
, nValues_function_value
, ( bp::arg("i") ) );
}
PackedArray2D_QString__exposer.def( bp::self != bp::self );
{ //::SireBase::PackedArray2D< QString >::operator()
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*__call___function_type )( ::quint32,::quint32 ) const;
__call___function_type __call___function_value( &::SireBase::PackedArray2D< QString >::operator() );
PackedArray2D_QString__exposer.def(
"__call__"
, __call___function_value
, ( bp::arg("i"), bp::arg("j") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::operator=
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QString > & ( ::SireBase::PackedArray2D< QString >::*assign_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
assign_function_type assign_function_value( &::SireBase::PackedArray2D< QString >::operator= );
PackedArray2D_QString__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PackedArray2D_QString__exposer.def( bp::self == bp::self );
{ //::SireBase::PackedArray2D< QString >::operator[]
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*__getitem___function_type )( ::quint32 ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PackedArray2D< QString >::operator[] );
PackedArray2D_QString__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::PackedArray2D< QString >::remove
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*remove_function_type )( ::quint32 ) ;
remove_function_type remove_function_value( &::SireBase::PackedArray2D< QString >::remove );
PackedArray2D_QString__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PackedArray2D< QString >::removeAll
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*removeAll_function_type )( ::QVarLengthArray< int, 256 > const & ) ;
removeAll_function_type removeAll_function_value( &::SireBase::PackedArray2D< QString >::removeAll );
PackedArray2D_QString__exposer.def(
"removeAll"
, removeAll_function_value
, ( bp::arg("idxs") ) );
}
{ //::SireBase::PackedArray2D< QString >::size
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef int ( ::SireBase::PackedArray2D< QString >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PackedArray2D< QString >::size );
PackedArray2D_QString__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toQVector
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QVector< QString > ( ::SireBase::PackedArray2D< QString >::*toQVector_function_type )( ) const;
toQVector_function_type toQVector_function_value( &::SireBase::PackedArray2D< QString >::toQVector );
PackedArray2D_QString__exposer.def(
"toQVector"
, toQVector_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toQVectorVector
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QVector< QVector< QString > > ( ::SireBase::PackedArray2D< QString >::*toQVectorVector_function_type )( ) const;
toQVectorVector_function_type toQVectorVector_function_value( &::SireBase::PackedArray2D< QString >::toQVectorVector );
PackedArray2D_QString__exposer.def(
"toQVectorVector"
, toQVectorVector_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toString
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::QString ( ::SireBase::PackedArray2D< QString >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PackedArray2D< QString >::toString );
PackedArray2D_QString__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PackedArray2D< QString >::toVariant
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef ::SireBase::PackedArray2D< QVariant > ( ::SireBase::PackedArray2D< QString >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireBase::PackedArray2D< QString >::toVariant );
PackedArray2D_QString__exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireBase::PackedArray2D< QString >::update
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
PackedArray2D_QString__exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::update
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::QVector< QString > const & ) ;
update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
PackedArray2D_QString__exposer.def(
"update"
, update_function_value
, ( bp::arg("i"), bp::arg("array") ) );
}
{ //::SireBase::PackedArray2D< QString >::updateAll
typedef SireBase::PackedArray2D< QString > exported_class_t;
typedef void ( ::SireBase::PackedArray2D< QString >::*updateAll_function_type )( ::QVarLengthArray< int, 256 > const &,::SireBase::PackedArray2D< QString > const & ) ;
updateAll_function_type updateAll_function_value( &::SireBase::PackedArray2D< QString >::updateAll );
PackedArray2D_QString__exposer.def(
"updateAll"
, updateAll_function_value
, ( bp::arg("idxs"), bp::arg("arrays") ) );
}
PackedArray2D_QString__exposer.staticmethod( "fromVariant" );
PackedArray2D_QString__exposer.def( "__copy__", &__copy__);
PackedArray2D_QString__exposer.def( "__deepcopy__", &__copy__);
PackedArray2D_QString__exposer.def( "clone", &__copy__);
PackedArray2D_QString__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_QString__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PackedArray2D_QString__exposer.def( "__str__", &__str__< ::SireBase::PackedArray2D<QString> > );
PackedArray2D_QString__exposer.def( "__repr__", &__str__< ::SireBase::PackedArray2D<QString> > );
PackedArray2D_QString__exposer.def( "__len__", &__len_size< ::SireBase::PackedArray2D<QString> > );
}
}
