Beispiel #1
0
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 );
    }

}
Beispiel #2
0
void register_Median_class(){

    { //::SireMaths::Median
        typedef bp::class_< SireMaths::Median, bp::bases< SireMaths::Accumulator, SireBase::Property > > Median_exposer_t;
        Median_exposer_t Median_exposer = Median_exposer_t( "Median", "This class is used to calculate the maximum, minimum and median\nof a collection of values\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an empty average") );
        bp::scope Median_scope( Median_exposer );
        Median_exposer.def( bp::init< SireMaths::Median const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMaths::Median::accumulate
        
            typedef void ( ::SireMaths::Median::*accumulate_function_type)( double ) ;
            accumulate_function_type accumulate_function_value( &::SireMaths::Median::accumulate );
            
            Median_exposer.def( 
                "accumulate"
                , accumulate_function_value
                , ( bp::arg("value") )
                , "Accumulate the passed value onto the average" );
        
        }
        { //::SireMaths::Median::clear
        
            typedef void ( ::SireMaths::Median::*clear_function_type)(  ) ;
            clear_function_type clear_function_value( &::SireMaths::Median::clear );
            
            Median_exposer.def( 
                "clear"
                , clear_function_value
                , "Completely clear the statistics in this accumulator" );
        
        }
        { //::SireMaths::Median::max
        
            typedef double ( ::SireMaths::Median::*max_function_type)(  ) const;
            max_function_type max_function_value( &::SireMaths::Median::max );
            
            Median_exposer.def( 
                "max"
                , max_function_value
                , "Return the maximum value" );
        
        }
        { //::SireMaths::Median::maximum
        
            typedef double ( ::SireMaths::Median::*maximum_function_type)(  ) const;
            maximum_function_type maximum_function_value( &::SireMaths::Median::maximum );
            
            Median_exposer.def( 
                "maximum"
                , maximum_function_value
                , "Return the maximum value" );
        
        }
        { //::SireMaths::Median::median
        
            typedef double ( ::SireMaths::Median::*median_function_type)(  ) const;
            median_function_type median_function_value( &::SireMaths::Median::median );
            
            Median_exposer.def( 
                "median"
                , median_function_value
                , "Return the median value" );
        
        }
        { //::SireMaths::Median::min
        
            typedef double ( ::SireMaths::Median::*min_function_type)(  ) const;
            min_function_type min_function_value( &::SireMaths::Median::min );
            
            Median_exposer.def( 
                "min"
                , min_function_value
                , "Return the minimum value" );
        
        }
        { //::SireMaths::Median::minimum
        
            typedef double ( ::SireMaths::Median::*minimum_function_type)(  ) const;
            minimum_function_type minimum_function_value( &::SireMaths::Median::minimum );
            
            Median_exposer.def( 
                "minimum"
                , minimum_function_value
                , "Return the minimum value" );
        
        }
        Median_exposer.def( bp::self != bp::self );
        { //::SireMaths::Median::operator=
        
            typedef ::SireMaths::Median & ( ::SireMaths::Median::*assign_function_type)( ::SireMaths::Median const & ) ;
            assign_function_type assign_function_value( &::SireMaths::Median::operator= );
            
            Median_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        Median_exposer.def( bp::self == bp::self );
        { //::SireMaths::Median::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::Median::typeName );
            
            Median_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        Median_exposer.staticmethod( "typeName" );
        Median_exposer.def( "__copy__", &__copy__);
        Median_exposer.def( "__deepcopy__", &__copy__);
        Median_exposer.def( "clone", &__copy__);
        Median_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Median >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Median_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Median >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Median_exposer.def( "__str__", &__str__< ::SireMaths::Median > );
        Median_exposer.def( "__repr__", &__str__< ::SireMaths::Median > );
    }

}
Beispiel #3
0
void register_MultiFixed_class(){

    { //::SireMaths::MultiFixed
        typedef bp::class_< SireMaths::MultiFixed > MultiFixed_exposer_t;
        MultiFixed_exposer_t MultiFixed_exposer = MultiFixed_exposer_t( "MultiFixed", "This class provides a vector of fixed point numbers which\nis built to complement MultiFloat. The number of fixed point\nnumbers in the vector is equal to the number of floats in MultiFloat.\n\nNote that this is a 64bit balanced fixed point representation,\ni.e. 32bits of precision are available both before and after\nthe decimal point (so about 9 significant figures on both sides,\nnote that the minus sign takes one of the bits before the decimal point).\n\nNote also that there are no functions that let you retrieve\nindividual fixed point numbers from this vector. Fixed point\nnumbers will automatically be converted tofrom doubles when\nreturned to the user.\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor - all of the elements are set to zero") );
        bp::scope MultiFixed_scope( MultiFixed_exposer );
        MultiFixed_exposer.def( bp::init< double >(( bp::arg("value") ), "Construct such that all elements are equal to value") );
        MultiFixed_exposer.def( bp::init< double const *, int >(( bp::arg("array"), bp::arg("size") ), "Construct from the passed array. If size is greater than MultiFixed::size()\nthen an error will be raised. If size is less than MultiFixed::size() then\nthis vector will be padded with zeroes") );
        MultiFixed_exposer.def( bp::init< QVector< double > const & >(( bp::arg("array") ), "Construct from the passed array. If size is greater than MultiFixed::size()\nthen an error will be raised. If size is less than MultiFixed::size() then\nthis vector will be padded with zeroes") );
        MultiFixed_exposer.def( bp::init< SireMaths::MultiFloat const & >(( bp::arg("value") ), "Construct from the passed MultiFloat") );
        MultiFixed_exposer.def( bp::init< SireMaths::MultiFixed const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMaths::MultiFixed::compareEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareEqual_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareEqual_function_type compareEqual_function_value( &::SireMaths::MultiFixed::compareEqual );
            
            MultiFixed_exposer.def( 
                "compareEqual"
                , compareEqual_function_value
                , ( bp::arg("other") )
                , "Compare each element of the two vectors. Return 0x00000000000000000 if\nthe element is not equal, 0x1111111111111111 if they are" );
        
        }
        { //::SireMaths::MultiFixed::compareGreater
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreater_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareGreater_function_type compareGreater_function_value( &::SireMaths::MultiFixed::compareGreater );
            
            MultiFixed_exposer.def( 
                "compareGreater"
                , compareGreater_function_value
                , ( bp::arg("other") )
                , "Compare each element for greater" );
        
        }
        { //::SireMaths::MultiFixed::compareGreaterEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreaterEqual_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareGreaterEqual_function_type compareGreaterEqual_function_value( &::SireMaths::MultiFixed::compareGreaterEqual );
            
            MultiFixed_exposer.def( 
                "compareGreaterEqual"
                , compareGreaterEqual_function_value
                , ( bp::arg("other") )
                , "Compare each element for greater or equal" );
        
        }
        { //::SireMaths::MultiFixed::compareLess
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLess_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareLess_function_type compareLess_function_value( &::SireMaths::MultiFixed::compareLess );
            
            MultiFixed_exposer.def( 
                "compareLess"
                , compareLess_function_value
                , ( bp::arg("other") )
                , "Compare each element for less" );
        
        }
        { //::SireMaths::MultiFixed::compareLessEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLessEqual_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareLessEqual_function_type compareLessEqual_function_value( &::SireMaths::MultiFixed::compareLessEqual );
            
            MultiFixed_exposer.def( 
                "compareLessEqual"
                , compareLessEqual_function_value
                , ( bp::arg("other") )
                , "Compare each element for less or equal" );
        
        }
        { //::SireMaths::MultiFixed::compareNotEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareNotEqual_function_type)( ::SireMaths::MultiFixed const & ) const;
            compareNotEqual_function_type compareNotEqual_function_value( &::SireMaths::MultiFixed::compareNotEqual );
            
            MultiFixed_exposer.def( 
                "compareNotEqual"
                , compareNotEqual_function_value
                , ( bp::arg("other") )
                , "Compare each element for inequality" );
        
        }
        { //::SireMaths::MultiFixed::count
        
            typedef int ( *count_function_type )(  );
            count_function_type count_function_value( &::SireMaths::MultiFixed::count );
            
            MultiFixed_exposer.def( 
                "count"
                , count_function_value
                , "Return the number of elements in the vector" );
        
        }
        { //::SireMaths::MultiFixed::fromArray
        
            typedef ::QVector< SireMaths::MultiFixed > ( *fromArray_function_type )( ::QVector< double > const & );
            fromArray_function_type fromArray_function_value( &::SireMaths::MultiFixed::fromArray );
            
            MultiFixed_exposer.def( 
                "fromArray"
                , fromArray_function_value
                , ( bp::arg("array") )
                , "Convert the passed array of doubles to an array of MultiFixed values.\nNote that the array may be returned padded with zeroes" );
        
        }
        { //::SireMaths::MultiFixed::get
        
            typedef double ( ::SireMaths::MultiFixed::*get_function_type)( int ) const;
            get_function_type get_function_value( &::SireMaths::MultiFixed::get );
            
            MultiFixed_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("i") )
                , "Return the value of the ith element of the vector" );
        
        }
        { //::SireMaths::MultiFixed::logicalAnd
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAnd_function_type)( ::SireMaths::MultiFixed const & ) const;
            logicalAnd_function_type logicalAnd_function_value( &::SireMaths::MultiFixed::logicalAnd );
            
            MultiFixed_exposer.def( 
                "logicalAnd"
                , logicalAnd_function_value
                , ( bp::arg("other") )
                , "Logical bitwise and operator" );
        
        }
        { //::SireMaths::MultiFixed::logicalAndNot
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAndNot_function_type)( ::SireMaths::MultiFixed const & ) const;
            logicalAndNot_function_type logicalAndNot_function_value( &::SireMaths::MultiFixed::logicalAndNot );
            
            MultiFixed_exposer.def( 
                "logicalAndNot"
                , logicalAndNot_function_value
                , ( bp::arg("other") )
                , "Logical bitwise and not" );
        
        }
        { //::SireMaths::MultiFixed::logicalNot
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalNot_function_type)(  ) const;
            logicalNot_function_type logicalNot_function_value( &::SireMaths::MultiFixed::logicalNot );
            
            MultiFixed_exposer.def( 
                "logicalNot"
                , logicalNot_function_value
                , "Logical bitwise not operator" );
        
        }
        { //::SireMaths::MultiFixed::logicalOr
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalOr_function_type)( ::SireMaths::MultiFixed const & ) const;
            logicalOr_function_type logicalOr_function_value( &::SireMaths::MultiFixed::logicalOr );
            
            MultiFixed_exposer.def( 
                "logicalOr"
                , logicalOr_function_value
                , ( bp::arg("other") )
                , "Logical bitwise or" );
        
        }
        { //::SireMaths::MultiFixed::logicalXor
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalXor_function_type)( ::SireMaths::MultiFixed const & ) const;
            logicalXor_function_type logicalXor_function_value( &::SireMaths::MultiFixed::logicalXor );
            
            MultiFixed_exposer.def( 
                "logicalXor"
                , logicalXor_function_value
                , ( bp::arg("other") )
                , "Logical bitwise xor" );
        
        }
        { //::SireMaths::MultiFixed::max
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*max_function_type)( ::SireMaths::MultiFixed const & ) const;
            max_function_type max_function_value( &::SireMaths::MultiFixed::max );
            
            MultiFixed_exposer.def( 
                "max"
                , max_function_value
                , ( bp::arg("other") )
                , "Return the max of this vector with other" );
        
        }
        { //::SireMaths::MultiFixed::min
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*min_function_type)( ::SireMaths::MultiFixed const & ) const;
            min_function_type min_function_value( &::SireMaths::MultiFixed::min );
            
            MultiFixed_exposer.def( 
                "min"
                , min_function_value
                , ( bp::arg("other") )
                , "Return the min of this vector with other" );
        
        }
        { //::SireMaths::MultiFixed::multiplyAdd
        
            typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*multiplyAdd_function_type)( ::SireMaths::MultiFixed const &,::SireMaths::MultiFixed const & ) ;
            multiplyAdd_function_type multiplyAdd_function_value( &::SireMaths::MultiFixed::multiplyAdd );
            
            MultiFixed_exposer.def( 
                "multiplyAdd"
                , multiplyAdd_function_value
                , ( bp::arg("val0"), bp::arg("val1") )
                , bp::return_self< >()
                , "Multiply val0 and val1 and add it onto this vector" );
        
        }
        MultiFixed_exposer.def( !bp::self );
        MultiFixed_exposer.def( bp::self != bp::self );
        MultiFixed_exposer.def( bp::self & bp::self );
        MultiFixed_exposer.def( bp::self * bp::self );
        MultiFixed_exposer.def( bp::self + bp::self );
        MultiFixed_exposer.def( -bp::self );
        MultiFixed_exposer.def( bp::self - bp::self );
        MultiFixed_exposer.def( bp::self / bp::self );
        MultiFixed_exposer.def( bp::self < bp::self );
        MultiFixed_exposer.def( bp::self <= bp::self );
        { //::SireMaths::MultiFixed::operator=
        
            typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*assign_function_type)( ::SireMaths::MultiFixed const & ) ;
            assign_function_type assign_function_value( &::SireMaths::MultiFixed::operator= );
            
            MultiFixed_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        MultiFixed_exposer.def( bp::self == bp::self );
        MultiFixed_exposer.def( bp::self > bp::self );
        MultiFixed_exposer.def( bp::self >= bp::self );
        { //::SireMaths::MultiFixed::operator[]
        
            typedef double ( ::SireMaths::MultiFixed::*__getitem___function_type)( int ) const;
            __getitem___function_type __getitem___function_value( &::SireMaths::MultiFixed::operator[] );
            
            MultiFixed_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        MultiFixed_exposer.def( bp::self ^ bp::self );
        MultiFixed_exposer.def( bp::self | bp::self );
        { //::SireMaths::MultiFixed::reciprocal
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*reciprocal_function_type)(  ) const;
            reciprocal_function_type reciprocal_function_value( &::SireMaths::MultiFixed::reciprocal );
            
            MultiFixed_exposer.def( 
                "reciprocal"
                , reciprocal_function_value
                , "Return the reciprocal of this number" );
        
        }
        { //::SireMaths::MultiFixed::rotate
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rotate_function_type)(  ) const;
            rotate_function_type rotate_function_value( &::SireMaths::MultiFixed::rotate );
            
            MultiFixed_exposer.def( 
                "rotate"
                , rotate_function_value
                , "Rotate this vector in the same direction as MultiFloat::rotate()" );
        
        }
        { //::SireMaths::MultiFixed::rsqrt
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rsqrt_function_type)(  ) const;
            rsqrt_function_type rsqrt_function_value( &::SireMaths::MultiFixed::rsqrt );
            
            MultiFixed_exposer.def( 
                "rsqrt"
                , rsqrt_function_value
                , "Return the reciprocal square root of this number" );
        
        }
        { //::SireMaths::MultiFixed::set
        
            typedef void ( ::SireMaths::MultiFixed::*set_function_type)( int,double ) ;
            set_function_type set_function_value( &::SireMaths::MultiFixed::set );
            
            MultiFixed_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("value") )
                , "Set the ith element of this vector to value" );
        
        }
        { //::SireMaths::MultiFixed::size
        
            typedef int ( *size_function_type )(  );
            size_function_type size_function_value( &::SireMaths::MultiFixed::size );
            
            MultiFixed_exposer.def( 
                "size"
                , size_function_value
                , "Return the number of elements in the vector" );
        
        }
        { //::SireMaths::MultiFixed::sqrt
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*sqrt_function_type)(  ) const;
            sqrt_function_type sqrt_function_value( &::SireMaths::MultiFixed::sqrt );
            
            MultiFixed_exposer.def( 
                "sqrt"
                , sqrt_function_value
                , "Return the square root of this number" );
        
        }
        { //::SireMaths::MultiFixed::sum
        
            typedef double ( ::SireMaths::MultiFixed::*sum_function_type)(  ) const;
            sum_function_type sum_function_value( &::SireMaths::MultiFixed::sum );
            
            MultiFixed_exposer.def( 
                "sum"
                , sum_function_value
                , "Return the sum of all of the elements of this vector" );
        
        }
        { //::SireMaths::MultiFixed::toArray
        
            typedef ::QVector< double > ( *toArray_function_type )( ::QVector< SireMaths::MultiFixed > const & );
            toArray_function_type toArray_function_value( &::SireMaths::MultiFixed::toArray );
            
            MultiFixed_exposer.def( 
                "toArray"
                , toArray_function_value
                , ( bp::arg("array") )
                , "Return convert the passed MultiFixed array back into an array of doubles" );
        
        }
        { //::SireMaths::MultiFixed::toBinaryString
        
            typedef ::QString ( ::SireMaths::MultiFixed::*toBinaryString_function_type)(  ) const;
            toBinaryString_function_type toBinaryString_function_value( &::SireMaths::MultiFixed::toBinaryString );
            
            MultiFixed_exposer.def( 
                "toBinaryString"
                , toBinaryString_function_value
                , "" );
        
        }
        { //::SireMaths::MultiFixed::toString
        
            typedef ::QString ( ::SireMaths::MultiFixed::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMaths::MultiFixed::toString );
            
            MultiFixed_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMaths::MultiFixed::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::MultiFixed::typeName );
            
            MultiFixed_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMaths::MultiFixed::what
        
            typedef char const * ( ::SireMaths::MultiFixed::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMaths::MultiFixed::what );
            
            MultiFixed_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        MultiFixed_exposer.staticmethod( "count" );
        MultiFixed_exposer.staticmethod( "fromArray" );
        MultiFixed_exposer.staticmethod( "size" );
        MultiFixed_exposer.staticmethod( "toArray" );
        MultiFixed_exposer.staticmethod( "typeName" );
        MultiFixed_exposer.def( "__copy__", &__copy__);
        MultiFixed_exposer.def( "__deepcopy__", &__copy__);
        MultiFixed_exposer.def( "clone", &__copy__);
        MultiFixed_exposer.def( "__str__", &__str__< ::SireMaths::MultiFixed > );
        MultiFixed_exposer.def( "__repr__", &__str__< ::SireMaths::MultiFixed > );
        MultiFixed_exposer.def( "__len__", &__len_size< ::SireMaths::MultiFixed > );
    }

}
Beispiel #4
0
void register_MultiFixed_class(){

    { //::SireMaths::MultiFixed
        typedef bp::class_< SireMaths::MultiFixed > MultiFixed_exposer_t;
        MultiFixed_exposer_t MultiFixed_exposer = MultiFixed_exposer_t( "MultiFixed", bp::init< >() );
        bp::scope MultiFixed_scope( MultiFixed_exposer );
        MultiFixed_exposer.def( bp::init< double >(( bp::arg("value") )) );
        MultiFixed_exposer.def( bp::init< double const *, int >(( bp::arg("array"), bp::arg("size") )) );
        MultiFixed_exposer.def( bp::init< QVector< double > const & >(( bp::arg("array") )) );
        MultiFixed_exposer.def( bp::init< SireMaths::MultiFloat const & >(( bp::arg("value") )) );
        MultiFixed_exposer.def( bp::init< SireMaths::MultiFixed const & >(( bp::arg("other") )) );
        { //::SireMaths::MultiFixed::compareEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareEqual_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareEqual_function_type compareEqual_function_value( &::SireMaths::MultiFixed::compareEqual );
            
            MultiFixed_exposer.def( 
                "compareEqual"
                , compareEqual_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::compareGreater
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreater_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareGreater_function_type compareGreater_function_value( &::SireMaths::MultiFixed::compareGreater );
            
            MultiFixed_exposer.def( 
                "compareGreater"
                , compareGreater_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::compareGreaterEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareGreaterEqual_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareGreaterEqual_function_type compareGreaterEqual_function_value( &::SireMaths::MultiFixed::compareGreaterEqual );
            
            MultiFixed_exposer.def( 
                "compareGreaterEqual"
                , compareGreaterEqual_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::compareLess
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLess_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareLess_function_type compareLess_function_value( &::SireMaths::MultiFixed::compareLess );
            
            MultiFixed_exposer.def( 
                "compareLess"
                , compareLess_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::compareLessEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareLessEqual_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareLessEqual_function_type compareLessEqual_function_value( &::SireMaths::MultiFixed::compareLessEqual );
            
            MultiFixed_exposer.def( 
                "compareLessEqual"
                , compareLessEqual_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::compareNotEqual
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*compareNotEqual_function_type )( ::SireMaths::MultiFixed const & ) const;
            compareNotEqual_function_type compareNotEqual_function_value( &::SireMaths::MultiFixed::compareNotEqual );
            
            MultiFixed_exposer.def( 
                "compareNotEqual"
                , compareNotEqual_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::count
        
            typedef int ( *count_function_type )(  );
            count_function_type count_function_value( &::SireMaths::MultiFixed::count );
            
            MultiFixed_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireMaths::MultiFixed::fromArray
        
            typedef ::QVector< SireMaths::MultiFixed > ( *fromArray_function_type )( ::QVector< double > const & );
            fromArray_function_type fromArray_function_value( &::SireMaths::MultiFixed::fromArray );
            
            MultiFixed_exposer.def( 
                "fromArray"
                , fromArray_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireMaths::MultiFixed::get
        
            typedef double ( ::SireMaths::MultiFixed::*get_function_type )( int ) const;
            get_function_type get_function_value( &::SireMaths::MultiFixed::get );
            
            MultiFixed_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMaths::MultiFixed::logicalAnd
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAnd_function_type )( ::SireMaths::MultiFixed const & ) const;
            logicalAnd_function_type logicalAnd_function_value( &::SireMaths::MultiFixed::logicalAnd );
            
            MultiFixed_exposer.def( 
                "logicalAnd"
                , logicalAnd_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::logicalAndNot
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalAndNot_function_type )( ::SireMaths::MultiFixed const & ) const;
            logicalAndNot_function_type logicalAndNot_function_value( &::SireMaths::MultiFixed::logicalAndNot );
            
            MultiFixed_exposer.def( 
                "logicalAndNot"
                , logicalAndNot_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::logicalNot
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalNot_function_type )(  ) const;
            logicalNot_function_type logicalNot_function_value( &::SireMaths::MultiFixed::logicalNot );
            
            MultiFixed_exposer.def( 
                "logicalNot"
                , logicalNot_function_value );
        
        }
        { //::SireMaths::MultiFixed::logicalOr
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalOr_function_type )( ::SireMaths::MultiFixed const & ) const;
            logicalOr_function_type logicalOr_function_value( &::SireMaths::MultiFixed::logicalOr );
            
            MultiFixed_exposer.def( 
                "logicalOr"
                , logicalOr_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::logicalXor
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*logicalXor_function_type )( ::SireMaths::MultiFixed const & ) const;
            logicalXor_function_type logicalXor_function_value( &::SireMaths::MultiFixed::logicalXor );
            
            MultiFixed_exposer.def( 
                "logicalXor"
                , logicalXor_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::max
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*max_function_type )( ::SireMaths::MultiFixed const & ) const;
            max_function_type max_function_value( &::SireMaths::MultiFixed::max );
            
            MultiFixed_exposer.def( 
                "max"
                , max_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::min
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*min_function_type )( ::SireMaths::MultiFixed const & ) const;
            min_function_type min_function_value( &::SireMaths::MultiFixed::min );
            
            MultiFixed_exposer.def( 
                "min"
                , min_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::MultiFixed::multiplyAdd
        
            typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*multiplyAdd_function_type )( ::SireMaths::MultiFixed const &,::SireMaths::MultiFixed const & ) ;
            multiplyAdd_function_type multiplyAdd_function_value( &::SireMaths::MultiFixed::multiplyAdd );
            
            MultiFixed_exposer.def( 
                "multiplyAdd"
                , multiplyAdd_function_value
                , ( bp::arg("val0"), bp::arg("val1") )
                , bp::return_self< >() );
        
        }
        MultiFixed_exposer.def( !bp::self );
        MultiFixed_exposer.def( bp::self != bp::self );
        MultiFixed_exposer.def( bp::self & bp::self );
        MultiFixed_exposer.def( bp::self * bp::self );
        MultiFixed_exposer.def( bp::self + bp::self );
        MultiFixed_exposer.def( -bp::self );
        MultiFixed_exposer.def( bp::self - bp::self );
        MultiFixed_exposer.def( bp::self / bp::self );
        MultiFixed_exposer.def( bp::self < bp::self );
        MultiFixed_exposer.def( bp::self <= bp::self );
        { //::SireMaths::MultiFixed::operator=
        
            typedef ::SireMaths::MultiFixed & ( ::SireMaths::MultiFixed::*assign_function_type )( ::SireMaths::MultiFixed const & ) ;
            assign_function_type assign_function_value( &::SireMaths::MultiFixed::operator= );
            
            MultiFixed_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        MultiFixed_exposer.def( bp::self == bp::self );
        MultiFixed_exposer.def( bp::self > bp::self );
        MultiFixed_exposer.def( bp::self >= bp::self );
        { //::SireMaths::MultiFixed::operator[]
        
            typedef double ( ::SireMaths::MultiFixed::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireMaths::MultiFixed::operator[] );
            
            MultiFixed_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        MultiFixed_exposer.def( bp::self ^ bp::self );
        MultiFixed_exposer.def( bp::self | bp::self );
        { //::SireMaths::MultiFixed::reciprocal
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*reciprocal_function_type )(  ) const;
            reciprocal_function_type reciprocal_function_value( &::SireMaths::MultiFixed::reciprocal );
            
            MultiFixed_exposer.def( 
                "reciprocal"
                , reciprocal_function_value );
        
        }
        { //::SireMaths::MultiFixed::rotate
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rotate_function_type )(  ) const;
            rotate_function_type rotate_function_value( &::SireMaths::MultiFixed::rotate );
            
            MultiFixed_exposer.def( 
                "rotate"
                , rotate_function_value );
        
        }
        { //::SireMaths::MultiFixed::rsqrt
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*rsqrt_function_type )(  ) const;
            rsqrt_function_type rsqrt_function_value( &::SireMaths::MultiFixed::rsqrt );
            
            MultiFixed_exposer.def( 
                "rsqrt"
                , rsqrt_function_value );
        
        }
        { //::SireMaths::MultiFixed::set
        
            typedef void ( ::SireMaths::MultiFixed::*set_function_type )( int,double ) ;
            set_function_type set_function_value( &::SireMaths::MultiFixed::set );
            
            MultiFixed_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("value") ) );
        
        }
        { //::SireMaths::MultiFixed::size
        
            typedef int ( *size_function_type )(  );
            size_function_type size_function_value( &::SireMaths::MultiFixed::size );
            
            MultiFixed_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireMaths::MultiFixed::sqrt
        
            typedef ::SireMaths::MultiFixed ( ::SireMaths::MultiFixed::*sqrt_function_type )(  ) const;
            sqrt_function_type sqrt_function_value( &::SireMaths::MultiFixed::sqrt );
            
            MultiFixed_exposer.def( 
                "sqrt"
                , sqrt_function_value );
        
        }
        { //::SireMaths::MultiFixed::sum
        
            typedef double ( ::SireMaths::MultiFixed::*sum_function_type )(  ) const;
            sum_function_type sum_function_value( &::SireMaths::MultiFixed::sum );
            
            MultiFixed_exposer.def( 
                "sum"
                , sum_function_value );
        
        }
        { //::SireMaths::MultiFixed::toArray
        
            typedef ::QVector< double > ( *toArray_function_type )( ::QVector< SireMaths::MultiFixed > const & );
            toArray_function_type toArray_function_value( &::SireMaths::MultiFixed::toArray );
            
            MultiFixed_exposer.def( 
                "toArray"
                , toArray_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireMaths::MultiFixed::toBinaryString
        
            typedef ::QString ( ::SireMaths::MultiFixed::*toBinaryString_function_type )(  ) const;
            toBinaryString_function_type toBinaryString_function_value( &::SireMaths::MultiFixed::toBinaryString );
            
            MultiFixed_exposer.def( 
                "toBinaryString"
                , toBinaryString_function_value );
        
        }
        { //::SireMaths::MultiFixed::toString
        
            typedef ::QString ( ::SireMaths::MultiFixed::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMaths::MultiFixed::toString );
            
            MultiFixed_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMaths::MultiFixed::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::MultiFixed::typeName );
            
            MultiFixed_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMaths::MultiFixed::what
        
            typedef char const * ( ::SireMaths::MultiFixed::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMaths::MultiFixed::what );
            
            MultiFixed_exposer.def( 
                "what"
                , what_function_value );
        
        }
        MultiFixed_exposer.staticmethod( "count" );
        MultiFixed_exposer.staticmethod( "fromArray" );
        MultiFixed_exposer.staticmethod( "size" );
        MultiFixed_exposer.staticmethod( "toArray" );
        MultiFixed_exposer.staticmethod( "typeName" );
        MultiFixed_exposer.def( "__copy__", &__copy__);
        MultiFixed_exposer.def( "__deepcopy__", &__copy__);
        MultiFixed_exposer.def( "clone", &__copy__);
        MultiFixed_exposer.def( "__str__", &__str__< ::SireMaths::MultiFixed > );
        MultiFixed_exposer.def( "__repr__", &__str__< ::SireMaths::MultiFixed > );
        MultiFixed_exposer.def( "__len__", &__len_size< ::SireMaths::MultiFixed > );
    }

}