Ejemplo n.º 1
0
void register_Perturbation_class(){

    { //::SireMol::Perturbation
        typedef bp::class_< SireMol::Perturbation, bp::bases< SireBase::Property >, boost::noncopyable > Perturbation_exposer_t;
        Perturbation_exposer_t Perturbation_exposer = Perturbation_exposer_t( "Perturbation", "This is the base class of all perturbation objects. A Perturbation\nis a rule for changing a property of a molecule with respect\nto a driving (reaction) coordinate. Perturbations can be used\nto implement single topology free energy calculations\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope Perturbation_scope( Perturbation_exposer );
        { //::SireMol::Perturbation::children
        
            typedef ::QList< SireBase::PropPtr< SireMol::Perturbation > > ( ::SireMol::Perturbation::*children_function_type)(  ) const;
            children_function_type children_function_value( &::SireMol::Perturbation::children );
            
            Perturbation_exposer.def( 
                "children"
                , children_function_value
                , "Return all of the child perturbations that make up\nthis perturbation" );
        
        }
        { //::SireMol::Perturbation::defaultFunction
        
            typedef ::SireCAS::Expression const & ( *defaultFunction_function_type )(  );
            defaultFunction_function_type defaultFunction_function_value( &::SireMol::Perturbation::defaultFunction );
            
            Perturbation_exposer.def( 
                "defaultFunction"
                , defaultFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the default mapping equation for the perturbations - this\nlinearly maps from the initial values at lambda=0 to the\nfinal value at lambda=1" );
        
        }
        { //::SireMol::Perturbation::mappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMol::Perturbation::*mappingFunction_function_type)(  ) const;
            mappingFunction_function_type mappingFunction_function_value( &::SireMol::Perturbation::mappingFunction );
            
            Perturbation_exposer.def( 
                "mappingFunction"
                , mappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the equation used to control the mapping from the\nthe initial value (represented using symbols().initial()) to\nthe final value (represented using symbols().final()) as a\nfunction of the reaction coordinate (which is normally\nrepresented using symbols().lambda())" );
        
        }
        { //::SireMol::Perturbation::null
        
            typedef ::SireMol::NullPerturbation const & ( *null_function_type )(  );
            null_function_type null_function_value( &::SireMol::Perturbation::null );
            
            Perturbation_exposer.def( 
                "null"
                , null_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::Perturbation::perturb
        
            typedef ::SireMol::Molecule ( ::SireMol::Perturbation::*perturb_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
            perturb_function_type perturb_function_value( &::SireMol::Perturbation::perturb );
            
            Perturbation_exposer.def( 
                "perturb"
                , perturb_function_value
                , ( bp::arg("molecule"), bp::arg("values") )
                , "Perturb the passed molecule, returning the result\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError:incompatible_error\n" );
        
        }
        { //::SireMol::Perturbation::propertyMap
        
            typedef ::SireBase::PropertyMap const & ( ::SireMol::Perturbation::*propertyMap_function_type)(  ) const;
            propertyMap_function_type propertyMap_function_value( &::SireMol::Perturbation::propertyMap );
            
            Perturbation_exposer.def( 
                "propertyMap"
                , propertyMap_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the property map used to find the properties used,\nand affected by this perturbation" );
        
        }
        { //::SireMol::Perturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)(  ) const;
            recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
            
            Perturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , "Recreate this perturbation - this has the same effect as .clone()" );
        
        }
        { //::SireMol::Perturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
            recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
            
            Perturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("mapping_function") )
                , "Recreate this perturbation, replacing its current mapping function\nwith mapping_function" );
        
        }
        { //::SireMol::Perturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireBase::PropertyMap const & ) const;
            recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
            
            Perturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("map") )
                , "Recreate this perturbation, replacing the current property map with map" );
        
        }
        { //::SireMol::Perturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
            recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate );
            
            Perturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("mapping_function"), bp::arg("map") )
                , "Recreate this perturbation, replacing both the mapping function and\nthe property map" );
        
        }
        { //::SireMol::Perturbation::requiredProperties
        
            typedef ::QSet< QString > ( ::SireMol::Perturbation::*requiredProperties_function_type)(  ) const;
            requiredProperties_function_type requiredProperties_function_value( &::SireMol::Perturbation::requiredProperties );
            
            Perturbation_exposer.def( 
                "requiredProperties"
                , requiredProperties_function_value
                , "" );
        
        }
        { //::SireMol::Perturbation::requiredSymbols
        
            typedef ::QSet< SireCAS::Symbol > ( ::SireMol::Perturbation::*requiredSymbols_function_type)(  ) const;
            requiredSymbols_function_type requiredSymbols_function_value( &::SireMol::Perturbation::requiredSymbols );
            
            Perturbation_exposer.def( 
                "requiredSymbols"
                , requiredSymbols_function_value
                , "Return all of the symbols that need to be supplied\nto the mapping function (i.e. ignoring symbols().initial()\nand symbols().final() )" );
        
        }
        { //::SireMol::Perturbation::substitute
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Symbol const &,::SireCAS::Symbol const & ) const;
            substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute );
            
            Perturbation_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("old_symbol"), bp::arg("new_symbol") )
                , "Substitute the symbol old_symbol with the symbol new_symbol\nin all of the mapping functions used by this perturbation. This is\nuseful if, for example, you want to switch from using\nlambda to control the perturbation to using alpha, e.g.\n" );
        
        }
        { //::SireMol::Perturbation::substitute
        
            typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute );
            
            Perturbation_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") )
                , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" );
        
        }
        { //::SireMol::Perturbation::symbols
        
            typedef ::SireMol::PerturbationSymbols const & ( *symbols_function_type )(  );
            symbols_function_type symbols_function_value( &::SireMol::Perturbation::symbols );
            
            Perturbation_exposer.def( 
                "symbols"
                , symbols_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the symbols object that contains the symbols used\nby the mapping equation" );
        
        }
        { //::SireMol::Perturbation::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::Perturbation::typeName );
            
            Perturbation_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMol::Perturbation::wouldChange
        
            typedef bool ( ::SireMol::Perturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
            wouldChange_function_type wouldChange_function_value( &::SireMol::Perturbation::wouldChange );
            
            Perturbation_exposer.def( 
                "wouldChange"
                , wouldChange_function_value
                , ( bp::arg("molecule"), bp::arg("values") )
                , "" );
        
        }
        Perturbation_exposer.staticmethod( "defaultFunction" );
        Perturbation_exposer.staticmethod( "null" );
        Perturbation_exposer.staticmethod( "symbols" );
        Perturbation_exposer.staticmethod( "typeName" );
        Perturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Perturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Perturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Perturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Perturbation_exposer.def( "__str__", &__str__< ::SireMol::Perturbation > );
        Perturbation_exposer.def( "__repr__", &__str__< ::SireMol::Perturbation > );
    }

}
Ejemplo n.º 2
0
void register_ExBase_class(){

    { //::SireCAS::ExBase
        typedef bp::class_< SireCAS::ExBase, boost::noncopyable > ExBase_exposer_t;
        ExBase_exposer_t ExBase_exposer = ExBase_exposer_t( "ExBase", "\nPure-virtual base class of all of the parts of mathematical expressions.\n\nThis class provides the atom of SireCAS. ExBase objects are combined together\nto form complete expressions. All constants, functions and symbols are derived\nfrom this object.\n\nThis class is an example of an implicitly shared, self-managed object, and\nis designed so that it can be held by SharedPolyPointer (indeed,\nExpressionBase is just a proxy for SharedPolyPointer<ExBase>).\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope ExBase_scope( ExBase_exposer );
        { //::SireCAS::ExBase::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::ExBase::*children_function_type)(  ) const;
            children_function_type children_function_value( &::SireCAS::ExBase::children );
            
            ExBase_exposer.def( 
                "children"
                , children_function_value
                , "Return the child expressions of this Expression" );
        
        }
        { //::SireCAS::ExBase::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*conjugate_function_type)(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::ExBase::conjugate );
            
            ExBase_exposer.def( 
                "conjugate"
                , conjugate_function_value
                , "Return the complex conjugate of this expression" );
        
        }
        { //::SireCAS::ExBase::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::ExBase::differentiate );
            
            ExBase_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") )
                , "Return an expression that the differential of this ExBase\nwith respect to symbol. Note an exception may\nbe thrown if this ExBase cannot be differentiated.\nThrow: SireCAS::unavailable_differential\n" );
        
        }
        { //::SireCAS::ExBase::evaluate
        
            typedef double ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
            
            ExBase_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") )
                , "Evaluate this ExBase using values values. Any\nmissing symbols are assumed to equal zero.\n\nNote that an exception will be thrown if the result of the\nevaluation of this, or one of its children, is complex.\n\nThrow: SireMaths::domain_error\n" );
        
        }
        { //::SireCAS::ExBase::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::ExBase::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::ExBase::evaluate );
            
            ExBase_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") )
                , "Evaluate this ExBase using the complex values values.\nAny missing symbols are assumed to equal zero." );
        
        }
        { //::SireCAS::ExBase::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExBase::*expand_function_type)( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::ExBase::expand );
            
            ExBase_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") )
                , "Rearrange this expression into the form\nm x^i + n x^j + ... + constant\nand return the factors and powers of x\n\nThrow: SireCAS::rearrangement_error\n" );
        
        }
        { //::SireCAS::ExBase::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::ExBase::*functions_function_type)(  ) const;
            functions_function_type functions_function_value( &::SireCAS::ExBase::functions );
            
            ExBase_exposer.def( 
                "functions"
                , functions_function_value
                , "Return the set of Functions that appear in this ExBase" );
        
        }
        { //::SireCAS::ExBase::hash
        
            typedef ::uint ( ::SireCAS::ExBase::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireCAS::ExBase::hash );
            
            ExBase_exposer.def( 
                "hash"
                , hash_function_value
                , "Return a hash of this object - return a combination of the\nidentifying magic for the class and a hash for its contents." );
        
        }
        { //::SireCAS::ExBase::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::ExBase::integrate );
            
            ExBase_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") )
                , "Return the indefinite integral of this ExBase with respect to\nsymbol. This is not guaranteed to work() and will return an\nexpression of the form Sum( integral(exbase) + integral_constant ).\nIf it doesnt work then an exception will be throw.\nThrow: SireCAS::unavailable_integral\n" );
        
        }
        { //::SireCAS::ExBase::isComplex
        
            typedef bool ( ::SireCAS::ExBase::*isComplex_function_type)(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::ExBase::isComplex );
            
            ExBase_exposer.def( 
                "isComplex"
                , isComplex_function_value
                , "Return whether or not this expression contains any complex (imaginary)\nparts" );
        
        }
        { //::SireCAS::ExBase::isCompound
        
            typedef bool ( ::SireCAS::ExBase::*isCompound_function_type)(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::ExBase::isCompound );
            
            ExBase_exposer.def( 
                "isCompound"
                , isCompound_function_value
                , "Return whether or not this is a compound expression, and thus as such\nrequires brackets placed around it when it is printed. Examples include\nSum, Product and Power. For most other functions it is safe to leave\nthis as false." );
        
        }
        { //::SireCAS::ExBase::isConstant
        
            typedef bool ( ::SireCAS::ExBase::*isConstant_function_type)(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::ExBase::isConstant );
            
            ExBase_exposer.def( 
                "isConstant"
                , isConstant_function_value
                , "Return whether or not this is a constant expression (does not\ndepend on any symbols)" );
        
        }
        { //::SireCAS::ExBase::isFunction
        
            typedef bool ( ::SireCAS::ExBase::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::ExBase::isFunction );
            
            ExBase_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") )
                , "Return whether or not this is a function of the passed Symbol" );
        
        }
        ExBase_exposer.def( bp::self != bp::self );
        ExBase_exposer.def( -bp::self );
        { //::SireCAS::ExBase::operator=
        
            typedef ::SireCAS::ExBase & ( ::SireCAS::ExBase::*assign_function_type)( ::SireCAS::ExBase const & ) ;
            assign_function_type assign_function_value( &::SireCAS::ExBase::operator= );
            
            ExBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("arg0") )
                , bp::return_self< >()
                , "Assignment operator" );
        
        }
        ExBase_exposer.def( bp::self == bp::self );
        { //::SireCAS::ExBase::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::ExBase::series );
            
            ExBase_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("n") )
                , "Return a series expansion of this expression with respect to\nsymbol, if possible, to order\nn. This is not guaranteed to work, and will return this expression\nunchanged if it doesnt work. If it is expanded, then a series\nwill be returned, together with an estimate of the error (e.g. O(x^2))" );
        
        }
        { //::SireCAS::ExBase::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*simplify_function_type)( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::ExBase::simplify );
            
            ExBase_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) )
                , "Try to simplify this expression. This will try to use known mathematical\nidentities to convert complex expressions down to more simple ones.\nIf SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is true, then identities\nthat are not safe for complex math are used, e.g. z = sin(arcsin(z))." );
        
        }
        { //::SireCAS::ExBase::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExBase::*substitute_function_type)( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::ExBase::substitute );
            
            ExBase_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") )
                , "Return an expression that has the identities in identities\nsubstituted into this expression" );
        
        }
        { //::SireCAS::ExBase::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::ExBase::*symbols_function_type)(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::ExBase::symbols );
            
            ExBase_exposer.def( 
                "symbols"
                , symbols_function_value
                , "Return the set of Symbols that appear in this ExBase" );
        
        }
        { //::SireCAS::ExBase::toOpenMMString
        
            typedef ::QString ( ::SireCAS::ExBase::*toOpenMMString_function_type)(  ) const;
            toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExBase::toOpenMMString );
            
            ExBase_exposer.def( 
                "toOpenMMString"
                , toOpenMMString_function_value
                , "Return a string representation of this object in the OpenMM syntax" );
        
        }
        { //::SireCAS::ExBase::toString
        
            typedef ::QString ( ::SireCAS::ExBase::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireCAS::ExBase::toString );
            
            ExBase_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this object" );
        
        }
        { //::SireCAS::ExBase::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::ExBase::typeName );
            
            ExBase_exposer.def( 
                "typeName"
                , typeName_function_value
                , "Return the name of this class type" );
        
        }
        { //::SireCAS::ExBase::what
        
            typedef char const * ( ::SireCAS::ExBase::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireCAS::ExBase::what );
            
            ExBase_exposer.def( 
                "what"
                , what_function_value
                , "Return the name of the type of this ExBase object" );
        
        }
        ExBase_exposer.staticmethod( "typeName" );
        ExBase_exposer.def( bp::self * bp::self );
        ExBase_exposer.def( bp::self * bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self * bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() * bp::self );
        ExBase_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self + bp::self );
        ExBase_exposer.def( bp::self + bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self + bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() + bp::self );
        ExBase_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self - bp::self );
        ExBase_exposer.def( bp::self - bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self - bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() - bp::self );
        ExBase_exposer.def( bp::self - bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( bp::self / bp::self );
        ExBase_exposer.def( bp::self / bp::other< SireCAS::Expression >() );
        ExBase_exposer.def( bp::self / bp::other< double >() );
        ExBase_exposer.def( bp::other< double >() / bp::self );
        ExBase_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        ExBase_exposer.def( self + self );
        ExBase_exposer.def( self - self );
        ExBase_exposer.def( self * self );
        ExBase_exposer.def( self / self );
        ExBase_exposer.def( other<double>() + self );
        ExBase_exposer.def( other<double>() - self );
        ExBase_exposer.def( other<double>() * self );
        ExBase_exposer.def( other<double>() / self );
        ExBase_exposer.def( self + other<double>() );
        ExBase_exposer.def( self - other<double>() );
        ExBase_exposer.def( self * other<double>() );
        ExBase_exposer.def( self / other<double>() );
        ExBase_exposer.def( other<SireMaths::Complex>() + self );
        ExBase_exposer.def( other<SireMaths::Complex>() - self );
        ExBase_exposer.def( other<SireMaths::Complex>() * self );
        ExBase_exposer.def( other<SireMaths::Complex>() / self );
        ExBase_exposer.def( self + other<SireMaths::Complex>() );
        ExBase_exposer.def( self - other<SireMaths::Complex>() );
        ExBase_exposer.def( self * other<SireMaths::Complex>() );
        ExBase_exposer.def( self / other<SireMaths::Complex>() );
        ExBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExBase_exposer.def( "__str__", &__str__< ::SireCAS::ExBase > );
        ExBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExBase > );
        ExBase_exposer.def( "__hash__", &::SireCAS::ExBase::hash );
    }

}
Ejemplo n.º 3
0
void register_InternalPerturbation_class(){

    { //::SireMM::InternalPerturbation
        typedef bp::class_< SireMM::InternalPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property >, boost::noncopyable > InternalPerturbation_exposer_t;
        InternalPerturbation_exposer_t InternalPerturbation_exposer = InternalPerturbation_exposer_t( "InternalPerturbation", "This is the base class of all internal perturbations - these\nare perturbations that change the internal potential of a\nmolecule (e.g. the bond, angle and dihedral parameters)\n\nInternal perturbation work by applying the mapping function\nto the identities in initialForm() and finalForm() and then\nsubstituting these identities into baseExpression(), e.g.\n\ninitialForm() :=>  k = k_{initial},  r0 = r0_{initial}\nfinalForm()   :=>  k = k_{final},    r0 = r0_{final}\n\nbaseExpression() :=>  k  (r - r0)2\n\nmappingFunction() :=>  (1-lam)initial + lamfinal\n\nThis will result in the the perturbing function being\n\nperturbFunction() :=> [ (1-lam)k_{initial} + lamk_{final} ]\n(r - [(1-lam)r0_{initial} + lamr0_{final}])2\n\nequally, if\n\ninitialForm() :=> f = 3  cos(5 phi)\nfinalForm()   :=> f = 5  cos(8 phi)\n\nbaseExpression() :=>  f\n\nmappingFunction() :=> (1-lam)initial + lamfinal\n\nThis will result in\n\nperturbFunction() :=> (1-lam)(3  cos(5 phi)) + lam  (5  cos(8 phi))\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope InternalPerturbation_scope( InternalPerturbation_exposer );
        { //::SireMM::InternalPerturbation::baseExpression
        
            typedef ::SireCAS::Expression const & ( ::SireMM::InternalPerturbation::*baseExpression_function_type)(  ) const;
            baseExpression_function_type baseExpression_function_value( &::SireMM::InternalPerturbation::baseExpression );
            
            InternalPerturbation_exposer.def( 
                "baseExpression"
                , baseExpression_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the base expression - this is the expression into which\nthe mapped identites are substituted" );
        
        }
        { //::SireMM::InternalPerturbation::finalForms
        
            typedef ::SireCAS::Identities const & ( ::SireMM::InternalPerturbation::*finalForms_function_type)(  ) const;
            finalForms_function_type finalForms_function_value( &::SireMM::InternalPerturbation::finalForms );
            
            InternalPerturbation_exposer.def( 
                "finalForms"
                , finalForms_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the final forms - these are the identities that\nare substituted into the base expression at the final state" );
        
        }
        { //::SireMM::InternalPerturbation::initialForms
        
            typedef ::SireCAS::Identities const & ( ::SireMM::InternalPerturbation::*initialForms_function_type)(  ) const;
            initialForms_function_type initialForms_function_value( &::SireMM::InternalPerturbation::initialForms );
            
            InternalPerturbation_exposer.def( 
                "initialForms"
                , initialForms_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the initial forms - these are the identities that\nare substituted into the base expression at the initial state" );
        
        }
        { //::SireMM::InternalPerturbation::perturbExpression
        
            typedef ::SireCAS::Expression const & ( ::SireMM::InternalPerturbation::*perturbExpression_function_type)(  ) const;
            perturbExpression_function_type perturbExpression_function_value( &::SireMM::InternalPerturbation::perturbExpression );
            
            InternalPerturbation_exposer.def( 
                "perturbExpression"
                , perturbExpression_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the perturbed expression - this is the expression that\nis used to calculate the energy" );
        
        }
        { //::SireMM::InternalPerturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::InternalPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
            recreate_function_type recreate_function_value( &::SireMM::InternalPerturbation::recreate );
            
            InternalPerturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("expression") )
                , "" );
        
        }
        { //::SireMM::InternalPerturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::InternalPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
            recreate_function_type recreate_function_value( &::SireMM::InternalPerturbation::recreate );
            
            InternalPerturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("expression"), bp::arg("map") )
                , "" );
        
        }
        { //::SireMM::InternalPerturbation::substitute
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::InternalPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireMM::InternalPerturbation::substitute );
            
            InternalPerturbation_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") )
                , "" );
        
        }
        { //::SireMM::InternalPerturbation::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::InternalPerturbation::typeName );
            
            InternalPerturbation_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        InternalPerturbation_exposer.staticmethod( "typeName" );
        InternalPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::InternalPerturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::InternalPerturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalPerturbation_exposer.def( "__str__", &__str__< ::SireMM::InternalPerturbation > );
        InternalPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::InternalPerturbation > );
    }

}
Ejemplo n.º 4
0
void register_Expression_class(){

    { //::SireCAS::Expression
        typedef bp::class_< SireCAS::Expression > Expression_exposer_t;
        Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() );
        bp::scope Expression_scope( Expression_exposer );
        Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) );
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::base
        
            typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )(  ) const;
            base_function_type base_function_value( &::SireCAS::Expression::base );
            
            Expression_exposer.def( 
                "base"
                , base_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireCAS::Expression::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Expression::children );
            
            Expression_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Expression::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate );
            
            Expression_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::Expression::cubed
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )(  ) const;
            cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed );
            
            Expression_exposer.def( 
                "cubed"
                , cubed_function_value );
        
        }
        { //::SireCAS::Expression::diff
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const;
            diff_function_type diff_function_value( &::SireCAS::Expression::diff );
            
            Expression_exposer.def( 
                "diff"
                , diff_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate );
            
            Expression_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Expression::expand );
            
            Expression_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::factor
        
            typedef double ( ::SireCAS::Expression::*factor_function_type )(  ) const;
            factor_function_type factor_function_value( &::SireCAS::Expression::factor );
            
            Expression_exposer.def( 
                "factor"
                , factor_function_value );
        
        }
        { //::SireCAS::Expression::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Expression::functions );
            
            Expression_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Expression::hash
        
            typedef ::uint ( ::SireCAS::Expression::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Expression::hash );
            
            Expression_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Expression::integ
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const;
            integ_function_type integ_function_value( &::SireCAS::Expression::integ );
            
            Expression_exposer.def( 
                "integ"
                , integ_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate );
            
            Expression_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::invert
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )(  ) const;
            invert_function_type invert_function_value( &::SireCAS::Expression::invert );
            
            Expression_exposer.def( 
                "invert"
                , invert_function_value );
        
        }
        { //::SireCAS::Expression::isComplex
        
            typedef bool ( ::SireCAS::Expression::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex );
            
            Expression_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::Expression::isCompound
        
            typedef bool ( ::SireCAS::Expression::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound );
            
            Expression_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::Expression::isConstant
        
            typedef bool ( ::SireCAS::Expression::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant );
            
            Expression_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Expression::isFunction
        
            typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction );
            
            Expression_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::isZero
        
            typedef bool ( ::SireCAS::Expression::*isZero_function_type )(  ) const;
            isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero );
            
            Expression_exposer.def( 
                "isZero"
                , isZero_function_value );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::negate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )(  ) const;
            negate_function_type negate_function_value( &::SireCAS::Expression::negate );
            
            Expression_exposer.def( 
                "negate"
                , negate_function_value );
        
        }
        Expression_exposer.def( bp::self != bp::self );
        { //::SireCAS::Expression::operator()
        
            typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::operator()
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        Expression_exposer.def( -bp::self );
        { //::SireCAS::Expression::operator=
        
            typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ;
            assign_function_type assign_function_value( &::SireCAS::Expression::operator= );
            
            Expression_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Expression_exposer.def( bp::self == bp::self );
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::root
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const;
            root_function_type root_function_value( &::SireCAS::Expression::root );
            
            Expression_exposer.def( 
                "root"
                , root_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::Expression::series );
            
            Expression_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("order") ) );
        
        }
        { //::SireCAS::Expression::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify );
            
            Expression_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::Expression::squared
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )(  ) const;
            squared_function_type squared_function_value( &::SireCAS::Expression::squared );
            
            Expression_exposer.def( 
                "squared"
                , squared_function_value );
        
        }
        { //::SireCAS::Expression::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute );
            
            Expression_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
            
            Expression_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Expression::toString
        
            typedef ::QString ( ::SireCAS::Expression::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Expression::toString );
            
            Expression_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Expression::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
            
            Expression_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Expression::what
        
            typedef char const * ( ::SireCAS::Expression::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Expression::what );
            
            Expression_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Expression_exposer.staticmethod( "typeName" );
        Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
        Expression_exposer.def( bp::self * bp::other< double >() );
        Expression_exposer.def( bp::other< double >() * bp::self );
        Expression_exposer.def( bp::self * bp::self );
        Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< double >() );
        Expression_exposer.def( bp::self + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< double >() - bp::self );
        Expression_exposer.def( bp::self - bp::other< double >() );
        Expression_exposer.def( bp::self - bp::self );
        Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< double >() );
        Expression_exposer.def( bp::self / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( self + self );
        Expression_exposer.def( self - self );
        Expression_exposer.def( self * self );
        Expression_exposer.def( self / self );
        Expression_exposer.def( other<double>() + self );
        Expression_exposer.def( other<double>() - self );
        Expression_exposer.def( other<double>() * self );
        Expression_exposer.def( other<double>() / self );
        Expression_exposer.def( self + other<double>() );
        Expression_exposer.def( self - other<double>() );
        Expression_exposer.def( self * other<double>() );
        Expression_exposer.def( self / other<double>() );
        Expression_exposer.def( other<SireMaths::Complex>() + self );
        Expression_exposer.def( other<SireMaths::Complex>() - self );
        Expression_exposer.def( other<SireMaths::Complex>() * self );
        Expression_exposer.def( other<SireMaths::Complex>() / self );
        Expression_exposer.def( self + other<SireMaths::Complex>() );
        Expression_exposer.def( self - other<SireMaths::Complex>() );
        Expression_exposer.def( self * other<SireMaths::Complex>() );
        Expression_exposer.def( self / other<SireMaths::Complex>() );
        Expression_exposer.def( other<SireCAS::ExBase>() + self );
        Expression_exposer.def( other<SireCAS::ExBase>() - self );
        Expression_exposer.def( other<SireCAS::ExBase>() * self );
        Expression_exposer.def( other<SireCAS::ExBase>() / self );
        Expression_exposer.def( self + other<SireCAS::ExBase>() );
        Expression_exposer.def( self - other<SireCAS::ExBase>() );
        Expression_exposer.def( self * other<SireCAS::ExBase>() );
        Expression_exposer.def( self / other<SireCAS::ExBase>() );
        Expression_exposer.def( "__copy__", &__copy__);
        Expression_exposer.def( "__deepcopy__", &__copy__);
        Expression_exposer.def( "clone", &__copy__);
        Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > );
        Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > );
    }

}
Ejemplo n.º 5
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 );
    }

}
Ejemplo n.º 6
0
void register_LJPerturbation_class(){

    { //::SireMM::LJPerturbation
        typedef bp::class_< SireMM::LJPerturbation, bp::bases< SireMol::Perturbation, SireBase::Property > > LJPerturbation_exposer_t;
        LJPerturbation_exposer_t LJPerturbation_exposer = LJPerturbation_exposer_t( "LJPerturbation", "This is a perturbation that maps LJ parameters for a molecule\nfrom an initial to a final state\n\nAuthor: Christopher Woods\n", bp::init< bp::optional< SireBase::PropertyMap const & > >(( bp::arg("map")=SireBase::PropertyMap() ), "Constructor - this creates a LJ perturbation that\nperturbs from LJs in initial_LJ to LJs in\nfinal_LJ, placing the current LJs in LJ,\nand using Perturbation::defaultEquation() to map the\nsigma and epsilon values of the LJ.") );
        bp::scope LJPerturbation_scope( LJPerturbation_exposer );
        bp::enum_< SireMM::LJPerturbation::MapType>("MapType")
            .value("MAP_SIGMA_AND_EPSILON", SireMM::LJPerturbation::MAP_SIGMA_AND_EPSILON)
            .value("MAP_RMIN_AND_EPSILON", SireMM::LJPerturbation::MAP_RMIN_AND_EPSILON)
            .value("MAP_A_AND_B", SireMM::LJPerturbation::MAP_A_AND_B)
            .export_values()
            ;
        LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation") );
        LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
        LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
        LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
        LJPerturbation_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const &, SireMM::LJPerturbation::MapType, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("sigma_mapping_function"), bp::arg("epsilon_mapping_function"), bp::arg("maptype"), bp::arg("map")=SireBase::PropertyMap() ), "Construct, using the passed map to find the properties used\nby this perturbation and the passed mapping function to map\nthe LJs between the states") );
        LJPerturbation_exposer.def( bp::init< SireMM::LJPerturbation const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::LJPerturbation::A_MappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*A_MappingFunction_function_type)(  ) const;
            A_MappingFunction_function_type A_MappingFunction_function_value( &::SireMM::LJPerturbation::A_MappingFunction );
            
            LJPerturbation_exposer.def( 
                "A_MappingFunction"
                , A_MappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to map A\nThrow: SireError::invalid_state\n" );
        
        }
        { //::SireMM::LJPerturbation::B_MappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*B_MappingFunction_function_type)(  ) const;
            B_MappingFunction_function_type B_MappingFunction_function_value( &::SireMM::LJPerturbation::B_MappingFunction );
            
            LJPerturbation_exposer.def( 
                "B_MappingFunction"
                , B_MappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to map B\nThrow: SireError::invalid_state\n" );
        
        }
        { //::SireMM::LJPerturbation::epsilonMappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*epsilonMappingFunction_function_type)(  ) const;
            epsilonMappingFunction_function_type epsilonMappingFunction_function_value( &::SireMM::LJPerturbation::epsilonMappingFunction );
            
            LJPerturbation_exposer.def( 
                "epsilonMappingFunction"
                , epsilonMappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to map epsilon\nThrow: SireError::invalid_state\n" );
        
        }
        { //::SireMM::LJPerturbation::mapAB
        
            typedef bool ( ::SireMM::LJPerturbation::*mapAB_function_type)(  ) const;
            mapAB_function_type mapAB_function_value( &::SireMM::LJPerturbation::mapAB );
            
            LJPerturbation_exposer.def( 
                "mapAB"
                , mapAB_function_value
                , "Return whether or not this maps A and B" );
        
        }
        { //::SireMM::LJPerturbation::mapRMinEpsilon
        
            typedef bool ( ::SireMM::LJPerturbation::*mapRMinEpsilon_function_type)(  ) const;
            mapRMinEpsilon_function_type mapRMinEpsilon_function_value( &::SireMM::LJPerturbation::mapRMinEpsilon );
            
            LJPerturbation_exposer.def( 
                "mapRMinEpsilon"
                , mapRMinEpsilon_function_value
                , "Return whether or not this maps r_min and epsilon" );
        
        }
        { //::SireMM::LJPerturbation::mapSigmaEpsilon
        
            typedef bool ( ::SireMM::LJPerturbation::*mapSigmaEpsilon_function_type)(  ) const;
            mapSigmaEpsilon_function_type mapSigmaEpsilon_function_value( &::SireMM::LJPerturbation::mapSigmaEpsilon );
            
            LJPerturbation_exposer.def( 
                "mapSigmaEpsilon"
                , mapSigmaEpsilon_function_value
                , "Return whether or not this maps sigma and epsilon" );
        
        }
        { //::SireMM::LJPerturbation::mappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*mappingFunction_function_type)(  ) const;
            mappingFunction_function_type mappingFunction_function_value( &::SireMM::LJPerturbation::mappingFunction );
            
            LJPerturbation_exposer.def( 
                "mappingFunction"
                , mappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the mapping function\nThrow: SireError::invalid_state\n" );
        
        }
        LJPerturbation_exposer.def( bp::self != bp::self );
        { //::SireMM::LJPerturbation::operator=
        
            typedef ::SireMM::LJPerturbation & ( ::SireMM::LJPerturbation::*assign_function_type)( ::SireMM::LJPerturbation const & ) ;
            assign_function_type assign_function_value( &::SireMM::LJPerturbation::operator= );
            
            LJPerturbation_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        LJPerturbation_exposer.def( bp::self == bp::self );
        { //::SireMM::LJPerturbation::rMinMappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*rMinMappingFunction_function_type)(  ) const;
            rMinMappingFunction_function_type rMinMappingFunction_function_value( &::SireMM::LJPerturbation::rMinMappingFunction );
            
            LJPerturbation_exposer.def( 
                "rMinMappingFunction"
                , rMinMappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to map r_min\nThrow: SireError::invalid_state\n" );
        
        }
        { //::SireMM::LJPerturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const;
            recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
            
            LJPerturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("mapping_function") )
                , "" );
        
        }
        { //::SireMM::LJPerturbation::recreate
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;
            recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );
            
            LJPerturbation_exposer.def( 
                "recreate"
                , recreate_function_value
                , ( bp::arg("mapping_function"), bp::arg("map") )
                , "" );
        
        }
        { //::SireMM::LJPerturbation::requiredProperties
        
            typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)(  ) const;
            requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties );
            
            LJPerturbation_exposer.def( 
                "requiredProperties"
                , requiredProperties_function_value
                , "Return the properties required or changed by this perturbation" );
        
        }
        { //::SireMM::LJPerturbation::sigmaMappingFunction
        
            typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)(  ) const;
            sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction );
            
            LJPerturbation_exposer.def( 
                "sigmaMappingFunction"
                , sigmaMappingFunction_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the function used to map sigma\nThrow: SireError::invalid_state\n" );
        
        }
        { //::SireMM::LJPerturbation::substitute
        
            typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute );
            
            LJPerturbation_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") )
                , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" );
        
        }
        { //::SireMM::LJPerturbation::toString
        
            typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString );
            
            LJPerturbation_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this perturbation" );
        
        }
        { //::SireMM::LJPerturbation::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName );
            
            LJPerturbation_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::LJPerturbation::wouldChange
        
            typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;
            wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange );
            
            LJPerturbation_exposer.def( 
                "wouldChange"
                , wouldChange_function_value
                , ( bp::arg("molecule"), bp::arg("values") )
                , "Return whether or not this perturbation with the passed values would\nchange the molecule molecule" );
        
        }
        LJPerturbation_exposer.staticmethod( "typeName" );
        LJPerturbation_exposer.def( "__copy__", &__copy__);
        LJPerturbation_exposer.def( "__deepcopy__", &__copy__);
        LJPerturbation_exposer.def( "clone", &__copy__);
        LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > );
        LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > );
    }

}
Ejemplo n.º 7
0
void register_ExpressionBase_class(){

    { //::SireCAS::ExpressionBase
        typedef bp::class_< SireCAS::ExpressionBase > ExpressionBase_exposer_t;
        ExpressionBase_exposer_t ExpressionBase_exposer = ExpressionBase_exposer_t( "ExpressionBase", bp::init< >() );
        bp::scope ExpressionBase_scope( ExpressionBase_exposer );
        ExpressionBase_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("ex") )) );
        ExpressionBase_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("other") )) );
        { //::SireCAS::ExpressionBase::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::ExpressionBase::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::ExpressionBase::children );
            
            ExpressionBase_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::ExpressionBase::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::ExpressionBase::conjugate );
            
            ExpressionBase_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::ExpressionBase::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::ExpressionBase::differentiate );
            
            ExpressionBase_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::ExpressionBase::evaluate
        
            typedef double ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate );
            
            ExpressionBase_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::ExpressionBase::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::ExpressionBase::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::ExpressionBase::evaluate );
            
            ExpressionBase_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::ExpressionBase::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::ExpressionBase::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::ExpressionBase::expand );
            
            ExpressionBase_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::ExpressionBase::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::ExpressionBase::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::ExpressionBase::functions );
            
            ExpressionBase_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::ExpressionBase::hash
        
            typedef ::uint ( ::SireCAS::ExpressionBase::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::ExpressionBase::hash );
            
            ExpressionBase_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::ExpressionBase::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::ExpressionBase::integrate );
            
            ExpressionBase_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::ExpressionBase::isComplex
        
            typedef bool ( ::SireCAS::ExpressionBase::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::ExpressionBase::isComplex );
            
            ExpressionBase_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::ExpressionBase::isCompound
        
            typedef bool ( ::SireCAS::ExpressionBase::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::ExpressionBase::isCompound );
            
            ExpressionBase_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::ExpressionBase::isConstant
        
            typedef bool ( ::SireCAS::ExpressionBase::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::ExpressionBase::isConstant );
            
            ExpressionBase_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::ExpressionBase::isFunction
        
            typedef bool ( ::SireCAS::ExpressionBase::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::ExpressionBase::isFunction );
            
            ExpressionBase_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") ) );
        
        }
        ExpressionBase_exposer.def( bp::self != bp::self );
        { //::SireCAS::ExpressionBase::operator=
        
            typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExpressionBase const & ) ;
            assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= );
            
            ExpressionBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireCAS::ExpressionBase::operator=
        
            typedef ::SireCAS::ExpressionBase & ( ::SireCAS::ExpressionBase::*assign_function_type )( ::SireCAS::ExBase const & ) ;
            assign_function_type assign_function_value( &::SireCAS::ExpressionBase::operator= );
            
            ExpressionBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        ExpressionBase_exposer.def( bp::self == bp::self );
        { //::SireCAS::ExpressionBase::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::ExpressionBase::series );
            
            ExpressionBase_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("n") ) );
        
        }
        { //::SireCAS::ExpressionBase::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::ExpressionBase::simplify );
            
            ExpressionBase_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::ExpressionBase::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::ExpressionBase::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::ExpressionBase::substitute );
            
            ExpressionBase_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::ExpressionBase::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::ExpressionBase::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::ExpressionBase::symbols );
            
            ExpressionBase_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::ExpressionBase::toString
        
            typedef ::QString ( ::SireCAS::ExpressionBase::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::ExpressionBase::toString );
            
            ExpressionBase_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::ExpressionBase::what
        
            typedef char const * ( ::SireCAS::ExpressionBase::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::ExpressionBase::what );
            
            ExpressionBase_exposer.def( 
                "what"
                , what_function_value );
        
        }
        ExpressionBase_exposer.def( "__copy__", &__copy__);
        ExpressionBase_exposer.def( "__deepcopy__", &__copy__);
        ExpressionBase_exposer.def( "clone", &__copy__);
        ExpressionBase_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::ExpressionBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExpressionBase_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::ExpressionBase >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ExpressionBase_exposer.def( "__str__", &__str__< ::SireCAS::ExpressionBase > );
        ExpressionBase_exposer.def( "__repr__", &__str__< ::SireCAS::ExpressionBase > );
    }

}
Ejemplo n.º 8
0
void register_Conditional_class(){

    { //::SireCAS::Conditional
        typedef bp::class_< SireCAS::Conditional, bp::bases< SireCAS::ExBase > > Conditional_exposer_t;
        Conditional_exposer_t Conditional_exposer = Conditional_exposer_t( "Conditional", "This is a conditional expression. If the condition is true,\nthen true_expression is evaluated, else if the condition\nis false then false_expression is evaluate\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope Conditional_scope( Conditional_exposer );
        Conditional_exposer.def( bp::init< SireCAS::Condition const &, SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("condition"), bp::arg("true_expression"), bp::arg("false_expression") ), "Construct a conditional where if condition is true, then\ntrue_expression is evaluated, while if condition is false,\nthen false_expression is evaluated") );
        Conditional_exposer.def( bp::init< SireCAS::Conditional const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireCAS::Conditional::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Conditional::*children_function_type)(  ) const;
            children_function_type children_function_value( &::SireCAS::Conditional::children );
            
            Conditional_exposer.def( 
                "children"
                , children_function_value
                , "Return the children of this expression" );
        
        }
        { //::SireCAS::Conditional::condition
        
            typedef ::SireCAS::Condition const & ( ::SireCAS::Conditional::*condition_function_type)(  ) const;
            condition_function_type condition_function_value( &::SireCAS::Conditional::condition );
            
            Conditional_exposer.def( 
                "condition"
                , condition_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "Return the condition" );
        
        }
        { //::SireCAS::Conditional::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*conjugate_function_type)(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Conditional::conjugate );
            
            Conditional_exposer.def( 
                "conjugate"
                , conjugate_function_value
                , "Return the complex conjugate of this expression" );
        
        }
        { //::SireCAS::Conditional::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Conditional::differentiate );
            
            Conditional_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") )
                , "Return the differential of this expression" );
        
        }
        { //::SireCAS::Conditional::evaluate
        
            typedef double ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
            
            Conditional_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") )
                , "Evaluate this expression for the passed values" );
        
        }
        { //::SireCAS::Conditional::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Conditional::*evaluate_function_type)( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Conditional::evaluate );
            
            Conditional_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") )
                , "Evaluate this expresion for the passed values" );
        
        }
        { //::SireCAS::Conditional::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Conditional::*expand_function_type)( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Conditional::expand );
            
            Conditional_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") )
                , "Expand this expression in terms of symbol" );
        
        }
        { //::SireCAS::Conditional::falseExpression
        
            typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*falseExpression_function_type)(  ) const;
            falseExpression_function_type falseExpression_function_value( &::SireCAS::Conditional::falseExpression );
            
            Conditional_exposer.def( 
                "falseExpression"
                , falseExpression_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the expression to be evaluated if the condition is false" );
        
        }
        { //::SireCAS::Conditional::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Conditional::*functions_function_type)(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Conditional::functions );
            
            Conditional_exposer.def( 
                "functions"
                , functions_function_value
                , "Return the functions used in this expression" );
        
        }
        { //::SireCAS::Conditional::hash
        
            typedef ::uint ( ::SireCAS::Conditional::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Conditional::hash );
            
            Conditional_exposer.def( 
                "hash"
                , hash_function_value
                , "Hash this conditional" );
        
        }
        { //::SireCAS::Conditional::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*integrate_function_type)( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Conditional::integrate );
            
            Conditional_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") )
                , "Return the integral of this expression" );
        
        }
        { //::SireCAS::Conditional::isComplex
        
            typedef bool ( ::SireCAS::Conditional::*isComplex_function_type)(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Conditional::isComplex );
            
            Conditional_exposer.def( 
                "isComplex"
                , isComplex_function_value
                , "Is this a complex expression?" );
        
        }
        { //::SireCAS::Conditional::isCompound
        
            typedef bool ( ::SireCAS::Conditional::*isCompound_function_type)(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Conditional::isCompound );
            
            Conditional_exposer.def( 
                "isCompound"
                , isCompound_function_value
                , "Is this a compound expression?" );
        
        }
        { //::SireCAS::Conditional::isConstant
        
            typedef bool ( ::SireCAS::Conditional::*isConstant_function_type)(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Conditional::isConstant );
            
            Conditional_exposer.def( 
                "isConstant"
                , isConstant_function_value
                , "Return whether or not this is constant" );
        
        }
        { //::SireCAS::Conditional::isFunction
        
            typedef bool ( ::SireCAS::Conditional::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Conditional::isFunction );
            
            Conditional_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") )
                , "Return whether or not this is a function of symbol" );
        
        }
        { //::SireCAS::Conditional::isNull
        
            typedef bool ( ::SireCAS::Conditional::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireCAS::Conditional::isNull );
            
            Conditional_exposer.def( 
                "isNull"
                , isNull_function_value
                , "Return whether or not this is null" );
        
        }
        { //::SireCAS::Conditional::operator=
        
            typedef ::SireCAS::Conditional & ( ::SireCAS::Conditional::*assign_function_type)( ::SireCAS::Conditional const & ) ;
            assign_function_type assign_function_value( &::SireCAS::Conditional::operator= );
            
            Conditional_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        Conditional_exposer.def( bp::self == bp::self );
        Conditional_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
        { //::SireCAS::Conditional::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*series_function_type)( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::Conditional::series );
            
            Conditional_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("n") )
                , "Return the series expansion of this product with respect to symbol, to order n" );
        
        }
        { //::SireCAS::Conditional::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*simplify_function_type)( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Conditional::simplify );
            
            Conditional_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) )
                , "Try to simplify this condition" );
        
        }
        { //::SireCAS::Conditional::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Conditional::*substitute_function_type)( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Conditional::substitute );
            
            Conditional_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") )
                , "Substitute identities into this expression" );
        
        }
        { //::SireCAS::Conditional::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Conditional::*symbols_function_type)(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Conditional::symbols );
            
            Conditional_exposer.def( 
                "symbols"
                , symbols_function_value
                , "Return the symbols used in this expression" );
        
        }
        { //::SireCAS::Conditional::toString
        
            typedef ::QString ( ::SireCAS::Conditional::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Conditional::toString );
            
            Conditional_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this conditional" );
        
        }
        { //::SireCAS::Conditional::trueExpression
        
            typedef ::SireCAS::Expression const & ( ::SireCAS::Conditional::*trueExpression_function_type)(  ) const;
            trueExpression_function_type trueExpression_function_value( &::SireCAS::Conditional::trueExpression );
            
            Conditional_exposer.def( 
                "trueExpression"
                , trueExpression_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the expression to be evaluated if the condition is true" );
        
        }
        { //::SireCAS::Conditional::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Conditional::typeName );
            
            Conditional_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireCAS::Conditional::what
        
            typedef char const * ( ::SireCAS::Conditional::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireCAS::Conditional::what );
            
            Conditional_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        Conditional_exposer.staticmethod( "typeName" );
        Conditional_exposer.def( "__copy__", &__copy__);
        Conditional_exposer.def( "__deepcopy__", &__copy__);
        Conditional_exposer.def( "clone", &__copy__);
        Conditional_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Conditional >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Conditional_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Conditional >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Conditional_exposer.def( "__str__", &__str__< ::SireCAS::Conditional > );
        Conditional_exposer.def( "__repr__", &__str__< ::SireCAS::Conditional > );
        Conditional_exposer.def( "__hash__", &::SireCAS::Conditional::hash );
    }

}
Ejemplo n.º 9
0
void register_Condition_class(){

    { //::SireCAS::Condition
        typedef bp::class_< SireCAS::Condition, bp::bases< SireCAS::ExBase >, boost::noncopyable > Condition_exposer_t;
        Condition_exposer_t Condition_exposer = Condition_exposer_t( "Condition", bp::no_init );
        bp::scope Condition_scope( Condition_exposer );
        { //::SireCAS::Condition::alwaysFalse
        
            typedef bool ( ::SireCAS::Condition::*alwaysFalse_function_type )(  ) const;
            alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::Condition::alwaysFalse );
            
            Condition_exposer.def( 
                "alwaysFalse"
                , alwaysFalse_function_value );
        
        }
        { //::SireCAS::Condition::alwaysTrue
        
            typedef bool ( ::SireCAS::Condition::*alwaysTrue_function_type )(  ) const;
            alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::Condition::alwaysTrue );
            
            Condition_exposer.def( 
                "alwaysTrue"
                , alwaysTrue_function_value );
        
        }
        { //::SireCAS::Condition::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Condition::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Condition::children );
            
            Condition_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Condition::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Condition::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Condition::conjugate );
            
            Condition_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::Condition::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Condition::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Condition::differentiate );
            
            Condition_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Condition::evaluate
        
            typedef double ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
            
            Condition_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Condition::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Condition::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Condition::evaluate );
            
            Condition_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Condition::evaluateCondition
        
            typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::Values const & ) const;
            evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
            
            Condition_exposer.def( 
                "evaluateCondition"
                , evaluateCondition_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Condition::evaluateCondition
        
            typedef bool ( ::SireCAS::Condition::*evaluateCondition_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluateCondition_function_type evaluateCondition_function_value( &::SireCAS::Condition::evaluateCondition );
            
            Condition_exposer.def( 
                "evaluateCondition"
                , evaluateCondition_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Condition::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Condition::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Condition::expand );
            
            Condition_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Condition::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Condition::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Condition::functions );
            
            Condition_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Condition::hash
        
            typedef ::uint ( ::SireCAS::Condition::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Condition::hash );
            
            Condition_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Condition::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Condition::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Condition::integrate );
            
            Condition_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Condition::isComplex
        
            typedef bool ( ::SireCAS::Condition::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Condition::isComplex );
            
            Condition_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::Condition::isCompound
        
            typedef bool ( ::SireCAS::Condition::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Condition::isCompound );
            
            Condition_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::Condition::isConstant
        
            typedef bool ( ::SireCAS::Condition::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Condition::isConstant );
            
            Condition_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Condition::isFunction
        
            typedef bool ( ::SireCAS::Condition::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Condition::isFunction );
            
            Condition_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") ) );
        
        }
        { //::SireCAS::Condition::isNull
        
            typedef bool ( ::SireCAS::Condition::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireCAS::Condition::isNull );
            
            Condition_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireCAS::Condition::leftHandSide
        
            typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*leftHandSide_function_type )(  ) const;
            leftHandSide_function_type leftHandSide_function_value( &::SireCAS::Condition::leftHandSide );
            
            Condition_exposer.def( 
                "leftHandSide"
                , leftHandSide_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireCAS::Condition::rightHandSide
        
            typedef ::SireCAS::Expression const & ( ::SireCAS::Condition::*rightHandSide_function_type )(  ) const;
            rightHandSide_function_type rightHandSide_function_value( &::SireCAS::Condition::rightHandSide );
            
            Condition_exposer.def( 
                "rightHandSide"
                , rightHandSide_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireCAS::Condition::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Condition::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Condition::simplify );
            
            Condition_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::Condition::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Condition::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Condition::substitute );
            
            Condition_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Condition::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Condition::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Condition::symbols );
            
            Condition_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Condition::toString
        
            typedef ::QString ( ::SireCAS::Condition::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Condition::toString );
            
            Condition_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Condition::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Condition::typeName );
            
            Condition_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        Condition_exposer.staticmethod( "typeName" );
        Condition_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Condition >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Condition_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Condition >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Condition_exposer.def( "__str__", &__str__< ::SireCAS::Condition > );
        Condition_exposer.def( "__repr__", &__str__< ::SireCAS::Condition > );
    }

}
Ejemplo n.º 10
0
void register_Product_class(){

    { //::SireCAS::Product
        typedef bp::class_< SireCAS::Product, bp::bases< SireCAS::ExBase > > Product_exposer_t;
        Product_exposer_t Product_exposer = Product_exposer_t( "Product", bp::init< >() );
        bp::scope Product_scope( Product_exposer );
        Product_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("ex0"), bp::arg("ex1") )) );
        Product_exposer.def( bp::init< SireCAS::Expressions const & >(( bp::arg("expressions") )) );
        Product_exposer.def( bp::init< SireCAS::Product const & >(( bp::arg("other") )) );
        { //::SireCAS::Product::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Product::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Product::children );
            
            Product_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Product::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Product::conjugate );
            
            Product_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::Product::denominator
        
            typedef ::SireCAS::Product ( ::SireCAS::Product::*denominator_function_type )(  ) const;
            denominator_function_type denominator_function_value( &::SireCAS::Product::denominator );
            
            Product_exposer.def( 
                "denominator"
                , denominator_function_value );
        
        }
        { //::SireCAS::Product::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Product::differentiate );
            
            Product_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Product::evaluate
        
            typedef double ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate );
            
            Product_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Product::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Product::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Product::evaluate );
            
            Product_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Product::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Product::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Product::expand );
            
            Product_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Product::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Product::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Product::functions );
            
            Product_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Product::hash
        
            typedef ::uint ( ::SireCAS::Product::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Product::hash );
            
            Product_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Product::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Product::integrate );
            
            Product_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Product::isComplex
        
            typedef bool ( ::SireCAS::Product::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Product::isComplex );
            
            Product_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::Product::isCompound
        
            typedef bool ( ::SireCAS::Product::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Product::isCompound );
            
            Product_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::Product::isConstant
        
            typedef bool ( ::SireCAS::Product::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Product::isConstant );
            
            Product_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Product::isFunction
        
            typedef bool ( ::SireCAS::Product::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Product::isFunction );
            
            Product_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") ) );
        
        }
        { //::SireCAS::Product::numerator
        
            typedef ::SireCAS::Product ( ::SireCAS::Product::*numerator_function_type )(  ) const;
            numerator_function_type numerator_function_value( &::SireCAS::Product::numerator );
            
            Product_exposer.def( 
                "numerator"
                , numerator_function_value );
        
        }
        Product_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
        { //::SireCAS::Product::reduce
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*reduce_function_type )(  ) const;
            reduce_function_type reduce_function_value( &::SireCAS::Product::reduce );
            
            Product_exposer.def( 
                "reduce"
                , reduce_function_value );
        
        }
        { //::SireCAS::Product::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::Product::series );
            
            Product_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("n") ) );
        
        }
        { //::SireCAS::Product::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Product::simplify );
            
            Product_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::Product::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Product::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Product::substitute );
            
            Product_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Product::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Product::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Product::symbols );
            
            Product_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Product::toString
        
            typedef ::QString ( ::SireCAS::Product::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Product::toString );
            
            Product_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Product::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Product::typeName );
            
            Product_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Product::what
        
            typedef char const * ( ::SireCAS::Product::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Product::what );
            
            Product_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Product_exposer.staticmethod( "typeName" );
        Product_exposer.def( "__copy__", &__copy__);
        Product_exposer.def( "__deepcopy__", &__copy__);
        Product_exposer.def( "clone", &__copy__);
        Product_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Product >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Product_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Product >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Product_exposer.def( "__str__", &__str__< ::SireCAS::Product > );
        Product_exposer.def( "__repr__", &__str__< ::SireCAS::Product > );
    }

}
Ejemplo n.º 11
0
void register_Symbol_class(){

    { //::SireCAS::Symbol
        typedef bp::class_< SireCAS::Symbol, bp::bases< SireCAS::ExBase > > Symbol_exposer_t;
        Symbol_exposer_t Symbol_exposer = Symbol_exposer_t( "Symbol", bp::init< >() );
        bp::scope Symbol_scope( Symbol_exposer );
        Symbol_exposer.def( bp::init< SireCAS::SymbolID >(( bp::arg("symid") )) );
        Symbol_exposer.def( bp::init< QString const & >(( bp::arg("rep") )) );
        Symbol_exposer.def( bp::init< SireCAS::Symbol const & >(( bp::arg("other") )) );
        { //::SireCAS::Symbol::ID
        
            typedef ::SireCAS::SymbolID ( ::SireCAS::Symbol::*ID_function_type )(  ) const;
            ID_function_type ID_function_value( &::SireCAS::Symbol::ID );
            
            Symbol_exposer.def( 
                "ID"
                , ID_function_value );
        
        }
        { //::SireCAS::Symbol::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Symbol::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Symbol::children );
            
            Symbol_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Symbol::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Symbol::differentiate );
            
            Symbol_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Symbol::evaluate
        
            typedef double ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
            
            Symbol_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Symbol::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Symbol::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Symbol::evaluate );
            
            Symbol_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Symbol::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Symbol::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Symbol::expand );
            
            Symbol_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Symbol::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Symbol::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Symbol::functions );
            
            Symbol_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Symbol::hash
        
            typedef ::uint ( ::SireCAS::Symbol::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Symbol::hash );
            
            Symbol_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Symbol::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Symbol::integrate );
            
            Symbol_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Symbol::isConstant
        
            typedef bool ( ::SireCAS::Symbol::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Symbol::isConstant );
            
            Symbol_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Symbol::isFunction
        
            typedef bool ( ::SireCAS::Symbol::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Symbol::isFunction );
            
            Symbol_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("arg0") ) );
        
        }
        { //::SireCAS::Symbol::isNull
        
            typedef bool ( ::SireCAS::Symbol::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireCAS::Symbol::isNull );
            
            Symbol_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        Symbol_exposer.def( bp::self < bp::self );
        Symbol_exposer.def( bp::self <= bp::self );
        { //::SireCAS::Symbol::operator=
        
            typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::Symbol const & ) ;
            assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
            
            Symbol_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireCAS::Symbol::operator=
        
            typedef ::SireCAS::Symbol & ( ::SireCAS::Symbol::*assign_function_type )( ::SireCAS::SymbolID ) ;
            assign_function_type assign_function_value( &::SireCAS::Symbol::operator= );
            
            Symbol_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("symid") )
                , bp::return_self< >() );
        
        }
        Symbol_exposer.def( bp::self == bp::other< double >() );
        Symbol_exposer.def( bp::self == bp::other< int >() );
        Symbol_exposer.def( bp::self == bp::other< SireMaths::Complex >() );
        Symbol_exposer.def( bp::self == bp::other< SireCAS::Expression >() );
        Symbol_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
        Symbol_exposer.def( bp::self > bp::self );
        Symbol_exposer.def( bp::self >= bp::self );
        { //::SireCAS::Symbol::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Symbol::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Symbol::substitute );
            
            Symbol_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Symbol::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Symbol::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Symbol::symbols );
            
            Symbol_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Symbol::toString
        
            typedef ::QString ( ::SireCAS::Symbol::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Symbol::toString );
            
            Symbol_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Symbol::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Symbol::typeName );
            
            Symbol_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Symbol::what
        
            typedef char const * ( ::SireCAS::Symbol::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Symbol::what );
            
            Symbol_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Symbol_exposer.staticmethod( "typeName" );
        Symbol_exposer.def( "__copy__", &__copy__);
        Symbol_exposer.def( "__deepcopy__", &__copy__);
        Symbol_exposer.def( "clone", &__copy__);
        Symbol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Symbol >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Symbol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Symbol >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Symbol_exposer.def( "__str__", &__str__< ::SireCAS::Symbol > );
        Symbol_exposer.def( "__repr__", &__str__< ::SireCAS::Symbol > );
    }

}