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 );
}
}
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::toOpenMMString
typedef ::QString ( ::SireCAS::ExpressionBase::*toOpenMMString_function_type )( ) const;
toOpenMMString_function_type toOpenMMString_function_value( &::SireCAS::ExpressionBase::toOpenMMString );
ExpressionBase_exposer.def(
"toOpenMMString"
, toOpenMMString_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 > );
}
}