void register_GridInfo_class(){
{ //::SireVol::GridInfo
typedef bp::class_< SireVol::GridInfo > GridInfo_exposer_t;
GridInfo_exposer_t GridInfo_exposer = GridInfo_exposer_t( "GridInfo", bp::init< >() );
bp::scope GridInfo_scope( GridInfo_exposer );
GridInfo_exposer.def( bp::init< SireVol::AABox const &, SireUnits::Dimension::Length >(( bp::arg("dimensions"), bp::arg("spacing") )) );
GridInfo_exposer.def( bp::init< SireVol::GridInfo const & >(( bp::arg("other") )) );
{ //::SireVol::GridInfo::arrayToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*arrayToGridIndex_function_type )( int ) const;
arrayToGridIndex_function_type arrayToGridIndex_function_value( &::SireVol::GridInfo::arrayToGridIndex );
GridInfo_exposer.def(
"arrayToGridIndex"
, arrayToGridIndex_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireVol::GridIndex const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( int,int,int ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::at
typedef int ( ::SireVol::GridInfo::*at_function_type )( ::SireMaths::Vector const & ) const;
at_function_type at_function_value( &::SireVol::GridInfo::at );
GridInfo_exposer.def(
"at"
, at_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( int ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireVol::GridIndex const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::box
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*box_function_type )( ::SireMaths::Vector const & ) const;
box_function_type box_function_value( &::SireVol::GridInfo::box );
GridInfo_exposer.def(
"box"
, box_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::closestIndexTo
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*closestIndexTo_function_type )( ::SireMaths::Vector const & ) const;
closestIndexTo_function_type closestIndexTo_function_value( &::SireVol::GridInfo::closestIndexTo );
GridInfo_exposer.def(
"closestIndexTo"
, closestIndexTo_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::contains
typedef bool ( ::SireVol::GridInfo::*contains_function_type )( ::SireMaths::Vector const & ) const;
contains_function_type contains_function_value( &::SireVol::GridInfo::contains );
GridInfo_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::count
typedef int ( ::SireVol::GridInfo::*count_function_type )( ) const;
count_function_type count_function_value( &::SireVol::GridInfo::count );
GridInfo_exposer.def(
"count"
, count_function_value );
}
{ //::SireVol::GridInfo::dimX
typedef ::qint32 ( ::SireVol::GridInfo::*dimX_function_type )( ) const;
dimX_function_type dimX_function_value( &::SireVol::GridInfo::dimX );
GridInfo_exposer.def(
"dimX"
, dimX_function_value );
}
{ //::SireVol::GridInfo::dimY
typedef ::qint32 ( ::SireVol::GridInfo::*dimY_function_type )( ) const;
dimY_function_type dimY_function_value( &::SireVol::GridInfo::dimY );
GridInfo_exposer.def(
"dimY"
, dimY_function_value );
}
{ //::SireVol::GridInfo::dimZ
typedef ::qint32 ( ::SireVol::GridInfo::*dimZ_function_type )( ) const;
dimZ_function_type dimZ_function_value( &::SireVol::GridInfo::dimZ );
GridInfo_exposer.def(
"dimZ"
, dimZ_function_value );
}
{ //::SireVol::GridInfo::dimensions
typedef ::SireVol::AABox ( ::SireVol::GridInfo::*dimensions_function_type )( ) const;
dimensions_function_type dimensions_function_value( &::SireVol::GridInfo::dimensions );
GridInfo_exposer.def(
"dimensions"
, dimensions_function_value );
}
{ //::SireVol::GridInfo::getitem
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*getitem_function_type )( int ) const;
getitem_function_type getitem_function_value( &::SireVol::GridInfo::getitem );
GridInfo_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( int,int,int ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("i"), bp::arg("j"), bp::arg("k") ) );
}
{ //::SireVol::GridInfo::gridToArrayIndex
typedef int ( ::SireVol::GridInfo::*gridToArrayIndex_function_type )( ::SireVol::GridIndex const & ) const;
gridToArrayIndex_function_type gridToArrayIndex_function_value( &::SireVol::GridInfo::gridToArrayIndex );
GridInfo_exposer.def(
"gridToArrayIndex"
, gridToArrayIndex_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( int,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("i"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::indexOf
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*indexOf_function_type )( ::SireVol::GridIndex const &,::SireVol::GridInfo const & ) const;
indexOf_function_type indexOf_function_value( &::SireVol::GridInfo::indexOf );
GridInfo_exposer.def(
"indexOf"
, indexOf_function_value
, ( bp::arg("idx"), bp::arg("grid") ) );
}
{ //::SireVol::GridInfo::isEmpty
typedef bool ( ::SireVol::GridInfo::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireVol::GridInfo::isEmpty );
GridInfo_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireVol::GridInfo::nPoints
typedef int ( ::SireVol::GridInfo::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireVol::GridInfo::nPoints );
GridInfo_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridInfo_exposer.def( bp::self != bp::self );
{ //::SireVol::GridInfo::operator=
typedef ::SireVol::GridInfo & ( ::SireVol::GridInfo::*assign_function_type )( ::SireVol::GridInfo const & ) ;
assign_function_type assign_function_value( &::SireVol::GridInfo::operator= );
GridInfo_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
GridInfo_exposer.def( bp::self == bp::self );
{ //::SireVol::GridInfo::operator[]
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireVol::GridIndex const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::operator[]
typedef int ( ::SireVol::GridInfo::*__getitem___function_type )( ::SireMaths::Vector const & ) const;
__getitem___function_type __getitem___function_value( &::SireVol::GridInfo::operator[] );
GridInfo_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireVol::GridIndex const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("idx") ) );
}
{ //::SireVol::GridInfo::point
typedef ::SireMaths::Vector ( ::SireVol::GridInfo::*point_function_type )( ::SireMaths::Vector const & ) const;
point_function_type point_function_value( &::SireVol::GridInfo::point );
GridInfo_exposer.def(
"point"
, point_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToArrayIndex
typedef int ( ::SireVol::GridInfo::*pointToArrayIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToArrayIndex_function_type pointToArrayIndex_function_value( &::SireVol::GridInfo::pointToArrayIndex );
GridInfo_exposer.def(
"pointToArrayIndex"
, pointToArrayIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef void ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::Vector const &,::QVector< int > &,::QVector< float > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("point"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies") ) );
}
{ //::SireVol::GridInfo::pointToGridCorners
typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;
pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );
GridInfo_exposer.def(
"pointToGridCorners"
, pointToGridCorners_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );
}
{ //::SireVol::GridInfo::pointToGridIndex
typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;
pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );
GridInfo_exposer.def(
"pointToGridIndex"
, pointToGridIndex_function_value
, ( bp::arg("point") ) );
}
{ //::SireVol::GridInfo::redimension
typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;
redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );
GridInfo_exposer.def(
"redimension"
, redimension_function_value
, ( bp::arg("values"), bp::arg("new_grid") ) );
}
{ //::SireVol::GridInfo::size
typedef int ( ::SireVol::GridInfo::*size_function_type )( ) const;
size_function_type size_function_value( &::SireVol::GridInfo::size );
GridInfo_exposer.def(
"size"
, size_function_value );
}
{ //::SireVol::GridInfo::spacing
typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )( ) const;
spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );
GridInfo_exposer.def(
"spacing"
, spacing_function_value );
}
{ //::SireVol::GridInfo::toString
typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireVol::GridInfo::toString );
GridInfo_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireVol::GridInfo::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );
GridInfo_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireVol::GridInfo::what
typedef char const * ( ::SireVol::GridInfo::*what_function_type )( ) const;
what_function_type what_function_value( &::SireVol::GridInfo::what );
GridInfo_exposer.def(
"what"
, what_function_value );
}
GridInfo_exposer.staticmethod( "typeName" );
GridInfo_exposer.def( "__copy__", &__copy__);
GridInfo_exposer.def( "__deepcopy__", &__copy__);
GridInfo_exposer.def( "clone", &__copy__);
GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );
GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );
}
}
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_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_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> > > );
}
}
