void register_MultiVector_class(){
{ //::SireMaths::MultiVector
typedef bp::class_< SireMaths::MultiVector > MultiVector_exposer_t;
MultiVector_exposer_t MultiVector_exposer = MultiVector_exposer_t( "MultiVector", "\nThis is a vectorised version of Vector, e.g. x, y, and z\nare held as MultiDouble objects, meaning that this is a\npacked vector of vectors\n\nAuthor: Christopher Woods\n", bp::init< >("") );
bp::scope MultiVector_scope( MultiVector_exposer );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const & >(( bp::arg("value") ), "Copy constructor") );
MultiVector_exposer.def( bp::init< SireMaths::MultiDouble const &, SireMaths::MultiDouble const &, SireMaths::MultiDouble const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") ), "") );
MultiVector_exposer.def( bp::init< SireMaths::Vector const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< QVector< SireMaths::Vector > const & >(( bp::arg("array") ), "Construct from an array of Vectors. This array cannot be greater\nthan MultiDouble::size()") );
MultiVector_exposer.def( bp::init< SireMaths::MultiVector const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the angle between vectors v0 and v1 - this is the smallest\nangle, and will always lie between 0 and 180 degrees" );
}
{ //::SireMaths::MultiVector::angle
typedef ::SireMaths::MultiDouble ( *angle_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
angle_function_type angle_function_value( &::SireMaths::MultiVector::angle );
MultiVector_exposer.def(
"angle"
, angle_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2") )
, "Return the angle between v0-v1-v2 (treating the vectors as points in space)" );
}
{ //::SireMaths::MultiVector::at
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMaths::MultiVector::at );
MultiVector_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::b
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*b_function_type)( ) const;
b_function_type b_function_value( &::SireMaths::MultiVector::b );
MultiVector_exposer.def(
"b"
, b_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::bearing
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearing_function_type)( ) const;
bearing_function_type bearing_function_value( &::SireMaths::MultiVector::bearing );
MultiVector_exposer.def(
"bearing"
, bearing_function_value
, "Return the bearing of this vector against (0,1,0) (north) on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXY
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXY_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXY_function_type bearingXY_function_value( &::SireMaths::MultiVector::bearingXY );
MultiVector_exposer.def(
"bearingXY"
, bearingXY_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xy plane" );
}
{ //::SireMaths::MultiVector::bearingXZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingXZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingXZ_function_type bearingXZ_function_value( &::SireMaths::MultiVector::bearingXZ );
MultiVector_exposer.def(
"bearingXZ"
, bearingXZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the xz plane" );
}
{ //::SireMaths::MultiVector::bearingYZ
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*bearingYZ_function_type)( ::SireMaths::MultiVector const & ) const;
bearingYZ_function_type bearingYZ_function_value( &::SireMaths::MultiVector::bearingYZ );
MultiVector_exposer.def(
"bearingYZ"
, bearingYZ_function_value
, ( bp::arg("v") )
, "Return the bearing of this vector against v on the yz plane" );
}
{ //::SireMaths::MultiVector::count
typedef int ( *count_function_type )( );
count_function_type count_function_value( &::SireMaths::MultiVector::count );
MultiVector_exposer.def(
"count"
, count_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::cross
typedef ::SireMaths::MultiVector ( *cross_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
cross_function_type cross_function_value( &::SireMaths::MultiVector::cross );
MultiVector_exposer.def(
"cross"
, cross_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the cross product of v0 and v1" );
}
{ //::SireMaths::MultiVector::dihedral
typedef ::SireMaths::MultiDouble ( *dihedral_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dihedral_function_type dihedral_function_value( &::SireMaths::MultiVector::dihedral );
MultiVector_exposer.def(
"dihedral"
, dihedral_function_value
, ( bp::arg("v0"), bp::arg("v1"), bp::arg("v2"), bp::arg("v3") )
, "Return the dihedral angle between v0-v1-v2-v3 (treating the vectors as points)" );
}
{ //::SireMaths::MultiVector::direction
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*direction_function_type)( ) const;
direction_function_type direction_function_value( &::SireMaths::MultiVector::direction );
MultiVector_exposer.def(
"direction"
, direction_function_value
, "Return the unit vector pointing in the direction of this vector" );
}
{ //::SireMaths::MultiVector::distance
typedef ::SireMaths::MultiDouble ( *distance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance_function_type distance_function_value( &::SireMaths::MultiVector::distance );
MultiVector_exposer.def(
"distance"
, distance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance between two vectors" );
}
{ //::SireMaths::MultiVector::distance2
typedef ::SireMaths::MultiDouble ( *distance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
distance2_function_type distance2_function_value( &::SireMaths::MultiVector::distance2 );
MultiVector_exposer.def(
"distance2"
, distance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the distance squared between two vectors" );
}
{ //::SireMaths::MultiVector::dot
typedef ::SireMaths::MultiDouble ( *dot_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
dot_function_type dot_function_value( &::SireMaths::MultiVector::dot );
MultiVector_exposer.def(
"dot"
, dot_function_value
, ( bp::arg("v0"), bp::arg("v1") )
, "Return the dot product of v0 and v1" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::SireMaths::Vector const *,int );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array"), bp::arg("size") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::fromArray
typedef ::QVector< SireMaths::MultiVector > ( *fromArray_function_type )( ::QVector< SireMaths::Vector > const & );
fromArray_function_type fromArray_function_value( &::SireMaths::MultiVector::fromArray );
MultiVector_exposer.def(
"fromArray"
, fromArray_function_value
, ( bp::arg("array") )
, "Convert the passed array of vectors into an array of MultiVectors" );
}
{ //::SireMaths::MultiVector::g
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*g_function_type)( ) const;
g_function_type g_function_value( &::SireMaths::MultiVector::g );
MultiVector_exposer.def(
"g"
, g_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::generate
typedef ::SireMaths::MultiVector ( *generate_function_type )( ::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const &,::SireMaths::MultiDouble const &,::SireMaths::MultiVector const & );
generate_function_type generate_function_value( &::SireMaths::MultiVector::generate );
MultiVector_exposer.def(
"generate"
, generate_function_value
, ( bp::arg("dst"), bp::arg("v1"), bp::arg("ang"), bp::arg("v2"), bp::arg("dih"), bp::arg("v3") )
, "Generate a vector, v0, that has distance dst v0-v1, angle ang v0-v1-v2,\nand dihedral dih v0-v1-v2-v3" );
}
{ //::SireMaths::MultiVector::getitem
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMaths::MultiVector::getitem );
MultiVector_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Access the ith vector in the MultiVector" );
}
{ //::SireMaths::MultiVector::invDistance
typedef ::SireMaths::MultiDouble ( *invDistance_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance_function_type invDistance_function_value( &::SireMaths::MultiVector::invDistance );
MultiVector_exposer.def(
"invDistance"
, invDistance_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return the 1 distance between two vectors" );
}
{ //::SireMaths::MultiVector::invDistance2
typedef ::SireMaths::MultiDouble ( *invDistance2_function_type )( ::SireMaths::MultiVector const &,::SireMaths::MultiVector const & );
invDistance2_function_type invDistance2_function_value( &::SireMaths::MultiVector::invDistance2 );
MultiVector_exposer.def(
"invDistance2"
, invDistance2_function_value
, ( bp::arg("v1"), bp::arg("v2") )
, "Return 1 distance2 between two vectors" );
}
{ //::SireMaths::MultiVector::invLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength_function_type)( ) const;
invLength_function_type invLength_function_value( &::SireMaths::MultiVector::invLength );
MultiVector_exposer.def(
"invLength"
, invLength_function_value
, "" );
}
{ //::SireMaths::MultiVector::invLength2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*invLength2_function_type)( ) const;
invLength2_function_type invLength2_function_value( &::SireMaths::MultiVector::invLength2 );
MultiVector_exposer.def(
"invLength2"
, invLength2_function_value
, "Return the inverse length squared" );
}
{ //::SireMaths::MultiVector::length
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length_function_type)( ) const;
length_function_type length_function_value( &::SireMaths::MultiVector::length );
MultiVector_exposer.def(
"length"
, length_function_value
, "" );
}
{ //::SireMaths::MultiVector::length2
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*length2_function_type)( ) const;
length2_function_type length2_function_value( &::SireMaths::MultiVector::length2 );
MultiVector_exposer.def(
"length2"
, length2_function_value
, "" );
}
{ //::SireMaths::MultiVector::magnitude
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*magnitude_function_type)( ) const;
magnitude_function_type magnitude_function_value( &::SireMaths::MultiVector::magnitude );
MultiVector_exposer.def(
"magnitude"
, magnitude_function_value
, "Return the length of this vector" );
}
{ //::SireMaths::MultiVector::manhattanLength
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*manhattanLength_function_type)( ) const;
manhattanLength_function_type manhattanLength_function_value( &::SireMaths::MultiVector::manhattanLength );
MultiVector_exposer.def(
"manhattanLength"
, manhattanLength_function_value
, "Return the manhattan length of the vector" );
}
{ //::SireMaths::MultiVector::max
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*max_function_type)( ::SireMaths::MultiVector const & ) const;
max_function_type max_function_value( &::SireMaths::MultiVector::max );
MultiVector_exposer.def(
"max"
, max_function_value
, ( bp::arg("other") )
, "Return a vector that has the maximum xyz components out of this\nand other" );
}
{ //::SireMaths::MultiVector::min
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*min_function_type)( ::SireMaths::MultiVector const & ) const;
min_function_type min_function_value( &::SireMaths::MultiVector::min );
MultiVector_exposer.def(
"min"
, min_function_value
, ( bp::arg("other") )
, "Return a vector that has the minimum components" );
}
{ //::SireMaths::MultiVector::normalise
typedef ::SireMaths::MultiVector ( ::SireMaths::MultiVector::*normalise_function_type)( ) const;
normalise_function_type normalise_function_value( &::SireMaths::MultiVector::normalise );
MultiVector_exposer.def(
"normalise"
, normalise_function_value
, "Return a normalised form of the vector" );
}
MultiVector_exposer.def( bp::self != bp::self );
MultiVector_exposer.def( -bp::self );
{ //::SireMaths::MultiVector::operator=
typedef ::SireMaths::MultiVector & ( ::SireMaths::MultiVector::*assign_function_type)( ::SireMaths::MultiVector const & ) ;
assign_function_type assign_function_value( &::SireMaths::MultiVector::operator= );
MultiVector_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
MultiVector_exposer.def( bp::self == bp::self );
{ //::SireMaths::MultiVector::operator[]
typedef ::SireMaths::Vector ( ::SireMaths::MultiVector::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::MultiVector::operator[] );
MultiVector_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, "" );
}
{ //::SireMaths::MultiVector::quickSet
typedef void ( ::SireMaths::MultiVector::*quickSet_function_type)( int,::SireMaths::Vector const & ) ;
quickSet_function_type quickSet_function_value( &::SireMaths::MultiVector::quickSet );
MultiVector_exposer.def(
"quickSet"
, quickSet_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Quickly set the values of the vector, without checking the index is valid" );
}
{ //::SireMaths::MultiVector::r
typedef ::SireMaths::MultiDouble ( ::SireMaths::MultiVector::*r_function_type)( ) const;
r_function_type r_function_value( &::SireMaths::MultiVector::r );
MultiVector_exposer.def(
"r"
, r_function_value
, "Return the components via rgb (limited between 0 and 1)" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( ::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const &,::SireMaths::MultiDouble const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("x"), bp::arg("y"), bp::arg("z") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::set
typedef void ( ::SireMaths::MultiVector::*set_function_type)( int,::SireMaths::Vector const & ) ;
set_function_type set_function_value( &::SireMaths::MultiVector::set );
MultiVector_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setB
typedef void ( ::SireMaths::MultiVector::*setB_function_type)( ::SireMaths::MultiDouble const & ) ;
setB_function_type setB_function_value( &::SireMaths::MultiVector::setB );
MultiVector_exposer.def(
"setB"
, setB_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setG
typedef void ( ::SireMaths::MultiVector::*setG_function_type)( ::SireMaths::MultiDouble const & ) ;
setG_function_type setG_function_value( &::SireMaths::MultiVector::setG );
MultiVector_exposer.def(
"setG"
, setG_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setMax
typedef void ( ::SireMaths::MultiVector::*setMax_function_type)( ::SireMaths::MultiVector const & ) ;
setMax_function_type setMax_function_value( &::SireMaths::MultiVector::setMax );
MultiVector_exposer.def(
"setMax"
, setMax_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the maximum xyz components out of\nthis and other (e.g. this->x = max(this->x(),other.x() etc.)" );
}
{ //::SireMaths::MultiVector::setMin
typedef void ( ::SireMaths::MultiVector::*setMin_function_type)( ::SireMaths::MultiVector const & ) ;
setMin_function_type setMin_function_value( &::SireMaths::MultiVector::setMin );
MultiVector_exposer.def(
"setMin"
, setMin_function_value
, ( bp::arg("other") )
, "Set this Vector so that it has the minimum xyz components" );
}
{ //::SireMaths::MultiVector::setR
typedef void ( ::SireMaths::MultiVector::*setR_function_type)( ::SireMaths::MultiDouble const & ) ;
setR_function_type setR_function_value( &::SireMaths::MultiVector::setR );
MultiVector_exposer.def(
"setR"
, setR_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setX
typedef void ( ::SireMaths::MultiVector::*setX_function_type)( ::SireMaths::MultiDouble const & ) ;
setX_function_type setX_function_value( &::SireMaths::MultiVector::setX );
MultiVector_exposer.def(
"setX"
, setX_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setY
typedef void ( ::SireMaths::MultiVector::*setY_function_type)( ::SireMaths::MultiDouble const & ) ;
setY_function_type setY_function_value( &::SireMaths::MultiVector::setY );
MultiVector_exposer.def(
"setY"
, setY_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::setZ
typedef void ( ::SireMaths::MultiVector::*setZ_function_type)( ::SireMaths::MultiDouble const & ) ;
setZ_function_type setZ_function_value( &::SireMaths::MultiVector::setZ );
MultiVector_exposer.def(
"setZ"
, setZ_function_value
, ( bp::arg("val") )
, "Set individual values of the vector" );
}
{ //::SireMaths::MultiVector::size
typedef int ( *size_function_type )( );
size_function_type size_function_value( &::SireMaths::MultiVector::size );
MultiVector_exposer.def(
"size"
, size_function_value
, "Return the number of vectors in this MultiVector" );
}
{ //::SireMaths::MultiVector::swap
typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int );
swap_function_type swap_function_value( &::SireMaths::MultiVector::swap );
MultiVector_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )
, "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );
}
{ //::SireMaths::MultiVector::toString
typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );
MultiVector_exposer.def(
"toString"
, toString_function_value
, "Return a QString representation of the vector" );
}
{ //::SireMaths::MultiVector::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );
MultiVector_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMaths::MultiVector::what
typedef char const * ( ::SireMaths::MultiVector::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMaths::MultiVector::what );
MultiVector_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireMaths::MultiVector::x
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)( ) const;
x_function_type x_function_value( &::SireMaths::MultiVector::x );
MultiVector_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::y
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*y_function_type)( ) const;
y_function_type y_function_value( &::SireMaths::MultiVector::y );
MultiVector_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMaths::MultiVector::z
typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*z_function_type)( ) const;
z_function_type z_function_value( &::SireMaths::MultiVector::z );
MultiVector_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
MultiVector_exposer.staticmethod( "angle" );
MultiVector_exposer.staticmethod( "count" );
MultiVector_exposer.staticmethod( "cross" );
MultiVector_exposer.staticmethod( "dihedral" );
MultiVector_exposer.staticmethod( "distance" );
MultiVector_exposer.staticmethod( "distance2" );
MultiVector_exposer.staticmethod( "dot" );
MultiVector_exposer.staticmethod( "fromArray" );
MultiVector_exposer.staticmethod( "generate" );
MultiVector_exposer.staticmethod( "invDistance" );
MultiVector_exposer.staticmethod( "invDistance2" );
MultiVector_exposer.staticmethod( "size" );
MultiVector_exposer.staticmethod( "swap" );
MultiVector_exposer.staticmethod( "typeName" );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( bp::self * bp::other< SireMaths::MultiQuaternion >() );
MultiVector_exposer.def( bp::self + bp::self );
MultiVector_exposer.def( bp::self - bp::self );
MultiVector_exposer.def( bp::self / bp::other< SireMaths::MultiDouble >() );
MultiVector_exposer.def( "__copy__", &__copy__);
MultiVector_exposer.def( "__deepcopy__", &__copy__);
MultiVector_exposer.def( "clone", &__copy__);
MultiVector_exposer.def( "__str__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__repr__", &__str__< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__len__", &__len_size< ::SireMaths::MultiVector > );
MultiVector_exposer.def( "__getitem__", &::SireMaths::MultiVector::getitem );
}
}
void register_DataPoint_class(){
{ //::SireAnalysis::DataPoint
typedef bp::class_< SireAnalysis::DataPoint > DataPoint_exposer_t;
DataPoint_exposer_t DataPoint_exposer = DataPoint_exposer_t( "DataPoint", "This class represents a single datapoint on an x,y graph. The point\nhas associated errors (small and large) on both the x and y axes\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor. This constructs the point (0,0) with no error") );
bp::scope DataPoint_scope( DataPoint_exposer );
DataPoint_exposer.def( bp::init< double, double >(( bp::arg("x"), bp::arg("y") ), "Construct the point (x,y) with no error") );
DataPoint_exposer.def( bp::init< double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xerror"), bp::arg("yerror") ), "Construct the point (x,y) with error (xerror,yerror)") );
DataPoint_exposer.def( bp::init< double, double, double, double, double, double >(( bp::arg("x"), bp::arg("y"), bp::arg("xminerror"), bp::arg("yminerror"), bp::arg("xmaxerror"), bp::arg("ymaxerror") ), "Construct the point (x,y) with a minimum error of (xminerror,yminerror)\nand a maximum error of (xmaxerror,ymaxerror). This is for situations where\nthere may be multiple different error measures on a point and you want\nto store the range of errors (based on a range of error estimates)") );
DataPoint_exposer.def( bp::init< SireAnalysis::DataPoint const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireAnalysis::DataPoint::equalWithinError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinError_function_type equalWithinError_function_value( &::SireAnalysis::DataPoint::equalWithinError );
DataPoint_exposer.def(
"equalWithinError"
, equalWithinError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point is equal to the other, within\nthe error range of the two points" );
}
{ //::SireAnalysis::DataPoint::equalWithinMaxError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMaxError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinMaxError_function_type equalWithinMaxError_function_value( &::SireAnalysis::DataPoint::equalWithinMaxError );
DataPoint_exposer.def(
"equalWithinMaxError"
, equalWithinMaxError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point in equal to the other, within\nthe maximum error range of the two points" );
}
{ //::SireAnalysis::DataPoint::equalWithinMinError
typedef bool ( ::SireAnalysis::DataPoint::*equalWithinMinError_function_type)( ::SireAnalysis::DataPoint const & ) const;
equalWithinMinError_function_type equalWithinMinError_function_value( &::SireAnalysis::DataPoint::equalWithinMinError );
DataPoint_exposer.def(
"equalWithinMinError"
, equalWithinMinError_function_value
, ( bp::arg("other") )
, "Return whether or not this data point in equal to the other, within\nthe minimum error range of the two points" );
}
{ //::SireAnalysis::DataPoint::hasError
typedef bool ( ::SireAnalysis::DataPoint::*hasError_function_type)( ) const;
hasError_function_type hasError_function_value( &::SireAnalysis::DataPoint::hasError );
DataPoint_exposer.def(
"hasError"
, hasError_function_value
, "Return whether or not this data point has any error" );
}
{ //::SireAnalysis::DataPoint::hasErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasErrorRange_function_type)( ) const;
hasErrorRange_function_type hasErrorRange_function_value( &::SireAnalysis::DataPoint::hasErrorRange );
DataPoint_exposer.def(
"hasErrorRange"
, hasErrorRange_function_value
, "Return whether or not this data point has an error range" );
}
{ //::SireAnalysis::DataPoint::hasXError
typedef bool ( ::SireAnalysis::DataPoint::*hasXError_function_type)( ) const;
hasXError_function_type hasXError_function_value( &::SireAnalysis::DataPoint::hasXError );
DataPoint_exposer.def(
"hasXError"
, hasXError_function_value
, "Return whether or not there is any error in the x value" );
}
{ //::SireAnalysis::DataPoint::hasXErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasXErrorRange_function_type)( ) const;
hasXErrorRange_function_type hasXErrorRange_function_value( &::SireAnalysis::DataPoint::hasXErrorRange );
DataPoint_exposer.def(
"hasXErrorRange"
, hasXErrorRange_function_value
, "Return whether or not there is an error range on the x value" );
}
{ //::SireAnalysis::DataPoint::hasYError
typedef bool ( ::SireAnalysis::DataPoint::*hasYError_function_type)( ) const;
hasYError_function_type hasYError_function_value( &::SireAnalysis::DataPoint::hasYError );
DataPoint_exposer.def(
"hasYError"
, hasYError_function_value
, "Return whether or not there is any error in the y value" );
}
{ //::SireAnalysis::DataPoint::hasYErrorRange
typedef bool ( ::SireAnalysis::DataPoint::*hasYErrorRange_function_type)( ) const;
hasYErrorRange_function_type hasYErrorRange_function_value( &::SireAnalysis::DataPoint::hasYErrorRange );
DataPoint_exposer.def(
"hasYErrorRange"
, hasYErrorRange_function_value
, "Return whether or not there is an error range on the x value" );
}
DataPoint_exposer.def( bp::self != bp::self );
{ //::SireAnalysis::DataPoint::operator=
typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ;
assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= );
DataPoint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
DataPoint_exposer.def( bp::self == bp::self );
{ //::SireAnalysis::DataPoint::toString
typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString );
DataPoint_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName );
DataPoint_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::what
typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)( ) const;
what_function_type what_function_value( &::SireAnalysis::DataPoint::what );
DataPoint_exposer.def(
"what"
, what_function_value
, "" );
}
{ //::SireAnalysis::DataPoint::x
typedef double ( ::SireAnalysis::DataPoint::*x_function_type)( ) const;
x_function_type x_function_value( &::SireAnalysis::DataPoint::x );
DataPoint_exposer.def(
"x"
, x_function_value
, "Return the x value of the point" );
}
{ //::SireAnalysis::DataPoint::xError
typedef double ( ::SireAnalysis::DataPoint::*xError_function_type)( ) const;
xError_function_type xError_function_value( &::SireAnalysis::DataPoint::xError );
DataPoint_exposer.def(
"xError"
, xError_function_value
, "Return the error on the x value. This is the average\nof the minimum and maximum error" );
}
{ //::SireAnalysis::DataPoint::xMaxError
typedef double ( ::SireAnalysis::DataPoint::*xMaxError_function_type)( ) const;
xMaxError_function_type xMaxError_function_value( &::SireAnalysis::DataPoint::xMaxError );
DataPoint_exposer.def(
"xMaxError"
, xMaxError_function_value
, "Return the maximum size of the error on the x value" );
}
{ //::SireAnalysis::DataPoint::xMinError
typedef double ( ::SireAnalysis::DataPoint::*xMinError_function_type)( ) const;
xMinError_function_type xMinError_function_value( &::SireAnalysis::DataPoint::xMinError );
DataPoint_exposer.def(
"xMinError"
, xMinError_function_value
, "Return the minimum size of the error on the x value" );
}
{ //::SireAnalysis::DataPoint::y
typedef double ( ::SireAnalysis::DataPoint::*y_function_type)( ) const;
y_function_type y_function_value( &::SireAnalysis::DataPoint::y );
DataPoint_exposer.def(
"y"
, y_function_value
, "Return the y value of the point" );
}
{ //::SireAnalysis::DataPoint::yError
typedef double ( ::SireAnalysis::DataPoint::*yError_function_type)( ) const;
yError_function_type yError_function_value( &::SireAnalysis::DataPoint::yError );
DataPoint_exposer.def(
"yError"
, yError_function_value
, "Return the error on the y value. This is the average\nof the minimum and maximum error" );
}
{ //::SireAnalysis::DataPoint::yMaxError
typedef double ( ::SireAnalysis::DataPoint::*yMaxError_function_type)( ) const;
yMaxError_function_type yMaxError_function_value( &::SireAnalysis::DataPoint::yMaxError );
DataPoint_exposer.def(
"yMaxError"
, yMaxError_function_value
, "Return the maximum size of the error on the y value" );
}
{ //::SireAnalysis::DataPoint::yMinError
typedef double ( ::SireAnalysis::DataPoint::*yMinError_function_type)( ) const;
yMinError_function_type yMinError_function_value( &::SireAnalysis::DataPoint::yMinError );
DataPoint_exposer.def(
"yMinError"
, yMinError_function_value
, "Return the minimum size of the error on the y value" );
}
DataPoint_exposer.staticmethod( "typeName" );
DataPoint_exposer.def( "__copy__", &__copy__);
DataPoint_exposer.def( "__deepcopy__", &__copy__);
DataPoint_exposer.def( "clone", &__copy__);
DataPoint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireAnalysis::DataPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DataPoint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireAnalysis::DataPoint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DataPoint_exposer.def( "__str__", &__str__< ::SireAnalysis::DataPoint > );
DataPoint_exposer.def( "__repr__", &__str__< ::SireAnalysis::DataPoint > );
}
}
void register_Velocity3D_class(){
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >
typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t;
Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() );
bp::scope Velocity3D_scope( Velocity3D_exposer );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) );
Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) );
Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at );
Velocity3D_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count );
Velocity3D_exposer.def(
"count"
, count_function_value );
}
Velocity3D_exposer.def( bp::self != bp::self );
Velocity3D_exposer.def( bp::self * bp::other< double >() );
Velocity3D_exposer.def( bp::self + bp::self );
Velocity3D_exposer.def( -bp::self );
Velocity3D_exposer.def( bp::self - bp::self );
Velocity3D_exposer.def( bp::self / bp::other< double >() );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator=
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ;
assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= );
Velocity3D_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Velocity3D_exposer.def( bp::self == bp::self );
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[]
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] );
Velocity3D_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ;
set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set );
Velocity3D_exposer.def(
"set"
, set_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString );
Velocity3D_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName );
Velocity3D_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireMaths::Vector ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*value_function_type )( ) const;
value_function_type value_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::value );
Velocity3D_exposer.def(
"value"
, value_function_value );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*x_function_type )( ) const;
x_function_type x_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::x );
Velocity3D_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*y_function_type )( ) const;
y_function_type y_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::y );
Velocity3D_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z
typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;
typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*z_function_type )( ) const;
z_function_type z_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::z );
Velocity3D_exposer.def(
"z"
, z_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
Velocity3D_exposer.staticmethod( "typeName" );
Velocity3D_exposer.def( "__copy__", &__copy__);
Velocity3D_exposer.def( "__deepcopy__", &__copy__);
Velocity3D_exposer.def( "clone", &__copy__);
Velocity3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Velocity3D_exposer.def( "__str__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__repr__", &__str__< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
Velocity3D_exposer.def( "__len__", &__len_count< ::SireMaths::Vector3D<SireUnits::Dimension::PhysUnit<0, 1, -1, 0, 0, 0, 0> > > );
}
}
void register_DoubleFunc_class(){
{ //::SireCAS::DoubleFunc
typedef bp::class_< SireCAS::DoubleFunc, bp::bases< SireCAS::ExBase >, boost::noncopyable > DoubleFunc_exposer_t;
DoubleFunc_exposer_t DoubleFunc_exposer = DoubleFunc_exposer_t( "DoubleFunc", "Base class of all double-expression functions ( e.g. f(x(), y()) )\n\nAuthor: Christopher Woods\n", bp::no_init );
bp::scope DoubleFunc_scope( DoubleFunc_exposer );
{ //::SireCAS::DoubleFunc::children
typedef ::SireCAS::Expressions ( ::SireCAS::DoubleFunc::*children_function_type)( ) const;
children_function_type children_function_value( &::SireCAS::DoubleFunc::children );
DoubleFunc_exposer.def(
"children"
, children_function_value
, "Return the child expression of this function" );
}
{ //::SireCAS::DoubleFunc::conjugate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*conjugate_function_type)( ) const;
conjugate_function_type conjugate_function_value( &::SireCAS::DoubleFunc::conjugate );
DoubleFunc_exposer.def(
"conjugate"
, conjugate_function_value
, "Return the conjugate of this function" );
}
{ //::SireCAS::DoubleFunc::differentiate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireCAS::DoubleFunc::differentiate );
DoubleFunc_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this function with respect to symbol" );
}
{ //::SireCAS::DoubleFunc::expand
typedef ::QList< SireCAS::Factor > ( ::SireCAS::DoubleFunc::*expand_function_type)( ::SireCAS::Symbol const & ) const;
expand_function_type expand_function_value( &::SireCAS::DoubleFunc::expand );
DoubleFunc_exposer.def(
"expand"
, expand_function_value
, ( bp::arg("symbol") )
, "" );
}
{ //::SireCAS::DoubleFunc::functions
typedef ::SireCAS::Functions ( ::SireCAS::DoubleFunc::*functions_function_type)( ) const;
functions_function_type functions_function_value( &::SireCAS::DoubleFunc::functions );
DoubleFunc_exposer.def(
"functions"
, functions_function_value
, "Return the functions used in this function" );
}
{ //::SireCAS::DoubleFunc::hash
typedef ::uint ( ::SireCAS::DoubleFunc::*hash_function_type)( ) const;
hash_function_type hash_function_value( &::SireCAS::DoubleFunc::hash );
DoubleFunc_exposer.def(
"hash"
, hash_function_value
, "Return a has for the function" );
}
{ //::SireCAS::DoubleFunc::integrate
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
integrate_function_type integrate_function_value( &::SireCAS::DoubleFunc::integrate );
DoubleFunc_exposer.def(
"integrate"
, integrate_function_value
, ( bp::arg("symbol") )
, "Return the integral of this function with respect to symbol" );
}
{ //::SireCAS::DoubleFunc::isComplex
typedef bool ( ::SireCAS::DoubleFunc::*isComplex_function_type)( ) const;
isComplex_function_type isComplex_function_value( &::SireCAS::DoubleFunc::isComplex );
DoubleFunc_exposer.def(
"isComplex"
, isComplex_function_value
, "Return whether this is complex" );
}
{ //::SireCAS::DoubleFunc::isCompound
typedef bool ( ::SireCAS::DoubleFunc::*isCompound_function_type)( ) const;
isCompound_function_type isCompound_function_value( &::SireCAS::DoubleFunc::isCompound );
DoubleFunc_exposer.def(
"isCompound"
, isCompound_function_value
, "A function is not compound" );
}
{ //::SireCAS::DoubleFunc::isConstant
typedef bool ( ::SireCAS::DoubleFunc::*isConstant_function_type)( ) const;
isConstant_function_type isConstant_function_value( &::SireCAS::DoubleFunc::isConstant );
DoubleFunc_exposer.def(
"isConstant"
, isConstant_function_value
, "Return whether or not this is constant" );
}
{ //::SireCAS::DoubleFunc::isFunction
typedef bool ( ::SireCAS::DoubleFunc::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
isFunction_function_type isFunction_function_value( &::SireCAS::DoubleFunc::isFunction );
DoubleFunc_exposer.def(
"isFunction"
, isFunction_function_value
, ( bp::arg("symbol") )
, "Return if this is a function of symbol" );
}
{ //::SireCAS::DoubleFunc::operator=
typedef ::SireCAS::DoubleFunc & ( ::SireCAS::DoubleFunc::*assign_function_type)( ::SireCAS::DoubleFunc const & ) ;
assign_function_type assign_function_value( &::SireCAS::DoubleFunc::operator= );
DoubleFunc_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireCAS::DoubleFunc::substitute
typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*substitute_function_type)( ::SireCAS::Identities const & ) const;
substitute_function_type substitute_function_value( &::SireCAS::DoubleFunc::substitute );
DoubleFunc_exposer.def(
"substitute"
, substitute_function_value
, ( bp::arg("identities") )
, "Substitute into this expression" );
}
{ //::SireCAS::DoubleFunc::symbols
typedef ::SireCAS::Symbols ( ::SireCAS::DoubleFunc::*symbols_function_type)( ) const;
symbols_function_type symbols_function_value( &::SireCAS::DoubleFunc::symbols );
DoubleFunc_exposer.def(
"symbols"
, symbols_function_value
, "Return the symbols used in this function" );
}
{ //::SireCAS::DoubleFunc::toString
typedef ::QString ( ::SireCAS::DoubleFunc::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireCAS::DoubleFunc::toString );
DoubleFunc_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this function" );
}
{ //::SireCAS::DoubleFunc::x
typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*x_function_type)( ) const;
x_function_type x_function_value( &::SireCAS::DoubleFunc::x );
DoubleFunc_exposer.def(
"x"
, x_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireCAS::DoubleFunc::y
typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*y_function_type)( ) const;
y_function_type y_function_value( &::SireCAS::DoubleFunc::y );
DoubleFunc_exposer.def(
"y"
, y_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
DoubleFunc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::DoubleFunc >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleFunc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::DoubleFunc >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleFunc_exposer.def( "__str__", &__str__< ::SireCAS::DoubleFunc > );
DoubleFunc_exposer.def( "__repr__", &__str__< ::SireCAS::DoubleFunc > );
DoubleFunc_exposer.def( "__hash__", &::SireCAS::DoubleFunc::hash );
}
}
