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 ); } }