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_DihedralRestraint_class(){
{ //::SireMM::DihedralRestraint
typedef bp::class_< SireMM::DihedralRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DihedralRestraint_exposer_t;
DihedralRestraint_exposer_t DihedralRestraint_exposer = DihedralRestraint_exposer_t( "DihedralRestraint", "This is a restraint that operates on the dihedral angle between\nfour SireMM::Point objects (e.g. four atoms in a molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope DihedralRestraint_scope( DihedralRestraint_exposer );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") ), "Construct a restraint that acts on the angle within the\nthree points point0, point1 and point2 (theta == a(012)),\nrestraining the angle within these points using the expression\nrestraint") );
DihedralRestraint_exposer.def( bp::init< SireMM::DihedralRestraint const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::DihedralRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::DihedralRestraint::*builtinSymbols_function_type)( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DihedralRestraint::builtinSymbols );
DihedralRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value
, "Return the built-in symbols for this restraint" );
}
{ //::SireMM::DihedralRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::DihedralRestraint::*builtinValues_function_type)( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::DihedralRestraint::builtinValues );
DihedralRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value
, "Return the values of the built-in symbols of this restraint" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") )
, "Return whether or not this restraint affects the molecule\nwith number molnum" );
}
{ //::SireMM::DihedralRestraint::contains
typedef bool ( ::SireMM::DihedralRestraint::*contains_function_type)( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::DihedralRestraint::contains );
DihedralRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") )
, "Return whether or not this restraint affects the molecule\nwith ID molid" );
}
{ //::SireMM::DihedralRestraint::differentialRestraintFunction
typedef ::SireCAS::Expression const & ( ::SireMM::DihedralRestraint::*differentialRestraintFunction_function_type)( ) const;
differentialRestraintFunction_function_type differentialRestraintFunction_function_value( &::SireMM::DihedralRestraint::differentialRestraintFunction );
DihedralRestraint_exposer.def(
"differentialRestraintFunction"
, differentialRestraintFunction_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the function used to calculate the restraint force" );
}
{ //::SireMM::DihedralRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::DihedralRestraint::*differentiate_function_type)( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::DihedralRestraint::differentiate );
DihedralRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") )
, "Return the differential of this restraint with respect to\nthe symbol symbol\nThrow: SireCAS::unavailable_differential\n" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecule in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::force
typedef void ( ::SireMM::DihedralRestraint::*force_function_type)( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DihedralRestraint::force );
DihedralRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 )
, "Calculate the force acting on the molecules in the forcetable forcetable\ncaused by this restraint, and add it on to the forcetable scaled by\nscale_force" );
}
{ //::SireMM::DihedralRestraint::halfHarmonic
typedef ::SireMM::DihedralRestraint ( *halfHarmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireUnits::Dimension::Angle const &,::SireMM::HarmonicAngleForceConstant const & );
halfHarmonic_function_type halfHarmonic_function_value( &::SireMM::DihedralRestraint::halfHarmonic );
DihedralRestraint_exposer.def(
"halfHarmonic"
, halfHarmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("angle"), bp::arg("force_constant") )
, "Return a distance restraint that applied a half-harmonic potential\nbetween the points point0 and point1 above a distance distance\nusing a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::harmonic
typedef ::SireMM::DihedralRestraint ( *harmonic_function_type )( ::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireFF::PointRef const &,::SireMM::HarmonicAngleForceConstant const & );
harmonic_function_type harmonic_function_value( &::SireMM::DihedralRestraint::harmonic );
DihedralRestraint_exposer.def(
"harmonic"
, harmonic_function_value
, ( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("force_constant") )
, "Return a distance restraint that applies a harmonic potential between\nthe points point0 and point1 using a force constant force_constant" );
}
{ //::SireMM::DihedralRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::DihedralRestraint::*molecules_function_type)( ) const;
molecules_function_type molecules_function_value( &::SireMM::DihedralRestraint::molecules );
DihedralRestraint_exposer.def(
"molecules"
, molecules_function_value
, "Return the molecules used in this restraint" );
}
{ //::SireMM::DihedralRestraint::nPoints
typedef int ( ::SireMM::DihedralRestraint::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireMM::DihedralRestraint::nPoints );
DihedralRestraint_exposer.def(
"nPoints"
, nPoints_function_value
, "This restraint involves four points" );
}
DihedralRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::DihedralRestraint::operator=
typedef ::SireMM::DihedralRestraint & ( ::SireMM::DihedralRestraint::*assign_function_type)( ::SireMM::DihedralRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::DihedralRestraint::operator= );
DihedralRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
DihedralRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::DihedralRestraint::phi
typedef ::SireCAS::Symbol const & ( *phi_function_type )( );
phi_function_type phi_function_value( &::SireMM::DihedralRestraint::phi );
DihedralRestraint_exposer.def(
"phi"
, phi_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the symbol that represents the dihedral angle between the points (phi)" );
}
{ //::SireMM::DihedralRestraint::point
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point_function_type)( int ) const;
point_function_type point_function_value( &::SireMM::DihedralRestraint::point );
DihedralRestraint_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the ith point" );
}
{ //::SireMM::DihedralRestraint::point0
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point0_function_type)( ) const;
point0_function_type point0_function_value( &::SireMM::DihedralRestraint::point0 );
DihedralRestraint_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the first point" );
}
{ //::SireMM::DihedralRestraint::point1
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point1_function_type)( ) const;
point1_function_type point1_function_value( &::SireMM::DihedralRestraint::point1 );
DihedralRestraint_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the second point" );
}
{ //::SireMM::DihedralRestraint::point2
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point2_function_type)( ) const;
point2_function_type point2_function_value( &::SireMM::DihedralRestraint::point2 );
DihedralRestraint_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the third point" );
}
{ //::SireMM::DihedralRestraint::point3
typedef ::SireFF::Point const & ( ::SireMM::DihedralRestraint::*point3_function_type)( ) const;
point3_function_type point3_function_value( &::SireMM::DihedralRestraint::point3 );
DihedralRestraint_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the fourth point" );
}
{ //::SireMM::DihedralRestraint::setSpace
typedef void ( ::SireMM::DihedralRestraint::*setSpace_function_type)( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::DihedralRestraint::setSpace );
DihedralRestraint_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") )
, "Set the space used to evaluate the energy of this restraint\nThrow: SireVol::incompatible_space\n" );
}
{ //::SireMM::DihedralRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::DihedralRestraint::typeName );
DihedralRestraint_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") )
, "Update the points of this restraint using new molecule data from moldata\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::update
typedef void ( ::SireMM::DihedralRestraint::*update_function_type)( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::DihedralRestraint::update );
DihedralRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") )
, "Update the points of this restraint using new molecule data from molecules\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") )
, "Return whether or not this restraint involves any of the molecules\nthat are in the forcetable forcetable" );
}
{ //::SireMM::DihedralRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DihedralRestraint::*usesMoleculesIn_function_type)( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DihedralRestraint::usesMoleculesIn );
DihedralRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") )
, "Return whether or not this restraint involves any of the molecules\nin molecules" );
}
DihedralRestraint_exposer.staticmethod( "halfHarmonic" );
DihedralRestraint_exposer.staticmethod( "harmonic" );
DihedralRestraint_exposer.staticmethod( "phi" );
DihedralRestraint_exposer.staticmethod( "typeName" );
DihedralRestraint_exposer.def( "__copy__", &__copy__);
DihedralRestraint_exposer.def( "__deepcopy__", &__copy__);
DihedralRestraint_exposer.def( "clone", &__copy__);
DihedralRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DihedralRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DihedralRestraint_exposer.def( "__str__", &__str__< ::SireMM::DihedralRestraint > );
DihedralRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DihedralRestraint > );
}
}
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 > );
}
}
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 );
}
}
void register_RestraintFF_class(){
{ //::SireMM::RestraintFF
typedef bp::class_< SireMM::RestraintFF, bp::bases< SireFF::FF3D, SireFF::G1FF, SireFF::FF, SireMol::MolGroupsBase, SireBase::Property > > RestraintFF_exposer_t;
RestraintFF_exposer_t RestraintFF_exposer = RestraintFF_exposer_t( "RestraintFF", bp::init< >() );
bp::scope RestraintFF_scope( RestraintFF_exposer );
RestraintFF_exposer.def( bp::init< QString const & >(( bp::arg("name") )) );
RestraintFF_exposer.def( bp::init< SireMM::RestraintFF const & >(( bp::arg("other") )) );
{ //::SireMM::RestraintFF::add
typedef bool ( ::SireMM::RestraintFF::*add_function_type )( ::SireMM::Restraint3D const & ) ;
add_function_type add_function_value( &::SireMM::RestraintFF::add );
RestraintFF_exposer.def(
"add"
, add_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::RestraintFF::builtinSymbols );
RestraintFF_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::RestraintFF::components
typedef ::SireMM::RestraintComponent const & ( ::SireMM::RestraintFF::*components_function_type )( ) const;
components_function_type components_function_value( &::SireMM::RestraintFF::components );
RestraintFF_exposer.def(
"components"
, components_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::contains
typedef bool ( ::SireMM::RestraintFF::*contains_function_type )( ::SireMM::Restraint3D const & ) const;
contains_function_type contains_function_value( &::SireMM::RestraintFF::contains );
RestraintFF_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::containsProperty
typedef bool ( ::SireMM::RestraintFF::*containsProperty_function_type )( ::QString const & ) const;
containsProperty_function_type containsProperty_function_value( &::SireMM::RestraintFF::containsProperty );
RestraintFF_exposer.def(
"containsProperty"
, containsProperty_function_value
, ( bp::arg("name") ) );
}
{ //::SireMM::RestraintFF::differentiate
typedef ::SireMM::RestraintFF ( ::SireMM::RestraintFF::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::RestraintFF::differentiate );
RestraintFF_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::field
typedef void ( ::SireMM::RestraintFF::*field_function_type )( ::SireFF::FieldTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
field_function_type field_function_value( &::SireMM::RestraintFF::field );
RestraintFF_exposer.def(
"field"
, field_function_value
, ( bp::arg("fieldtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_field")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::force
typedef void ( ::SireMM::RestraintFF::*force_function_type )( ::SireFF::ForceTable &,::SireCAS::Symbol const &,double ) ;
force_function_type force_function_value( &::SireMM::RestraintFF::force );
RestraintFF_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("symbol"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::RestraintFF::getValue
typedef double ( ::SireMM::RestraintFF::*getValue_function_type )( ::SireCAS::Symbol const & ) const;
getValue_function_type getValue_function_value( &::SireMM::RestraintFF::getValue );
RestraintFF_exposer.def(
"getValue"
, getValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::hasValue
typedef bool ( ::SireMM::RestraintFF::*hasValue_function_type )( ::SireCAS::Symbol const & ) const;
hasValue_function_type hasValue_function_value( &::SireMM::RestraintFF::hasValue );
RestraintFF_exposer.def(
"hasValue"
, hasValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::RestraintFF::mustNowRecalculateFromScratch
typedef void ( ::SireMM::RestraintFF::*mustNowRecalculateFromScratch_function_type )( ) ;
mustNowRecalculateFromScratch_function_type mustNowRecalculateFromScratch_function_value( &::SireMM::RestraintFF::mustNowRecalculateFromScratch );
RestraintFF_exposer.def(
"mustNowRecalculateFromScratch"
, mustNowRecalculateFromScratch_function_value );
}
{ //::SireMM::RestraintFF::nRestraints
typedef int ( ::SireMM::RestraintFF::*nRestraints_function_type )( ) const;
nRestraints_function_type nRestraints_function_value( &::SireMM::RestraintFF::nRestraints );
RestraintFF_exposer.def(
"nRestraints"
, nRestraints_function_value );
}
RestraintFF_exposer.def( bp::self != bp::self );
{ //::SireMM::RestraintFF::operator=
typedef ::SireMM::RestraintFF & ( ::SireMM::RestraintFF::*assign_function_type )( ::SireMM::RestraintFF const & ) ;
assign_function_type assign_function_value( &::SireMM::RestraintFF::operator= );
RestraintFF_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
RestraintFF_exposer.def( bp::self == bp::self );
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::potential
typedef void ( ::SireMM::RestraintFF::*potential_function_type )( ::SireFF::PotentialTable &,::SireCAS::Symbol const &,::SireFF::Probe const &,double ) ;
potential_function_type potential_function_value( &::SireMM::RestraintFF::potential );
RestraintFF_exposer.def(
"potential"
, potential_function_value
, ( bp::arg("potentialtable"), bp::arg("component"), bp::arg("probe"), bp::arg("scale_potential")=1 ) );
}
{ //::SireMM::RestraintFF::properties
typedef ::SireBase::Properties const & ( ::SireMM::RestraintFF::*properties_function_type )( ) const;
properties_function_type properties_function_value( &::SireMM::RestraintFF::properties );
RestraintFF_exposer.def(
"properties"
, properties_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::RestraintFF::property
typedef ::SireBase::Property const & ( ::SireMM::RestraintFF::*property_function_type )( ::QString const & ) const;
property_function_type property_function_value( &::SireMM::RestraintFF::property );
RestraintFF_exposer.def(
"property"
, property_function_value
, ( bp::arg("name") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::remove
typedef bool ( ::SireMM::RestraintFF::*remove_function_type )( ::SireMM::Restraint3D const & ) ;
remove_function_type remove_function_value( &::SireMM::RestraintFF::remove );
RestraintFF_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("restraint") ) );
}
{ //::SireMM::RestraintFF::removeRestraintAt
typedef void ( ::SireMM::RestraintFF::*removeRestraintAt_function_type )( int ) ;
removeRestraintAt_function_type removeRestraintAt_function_value( &::SireMM::RestraintFF::removeRestraintAt );
RestraintFF_exposer.def(
"removeRestraintAt"
, removeRestraintAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireMM::RestraintFF::restraintAt
typedef ::SireMM::Restraint3D const & ( ::SireMM::RestraintFF::*restraintAt_function_type )( int ) const;
restraintAt_function_type restraintAt_function_value( &::SireMM::RestraintFF::restraintAt );
RestraintFF_exposer.def(
"restraintAt"
, restraintAt_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::restraints
typedef ::QVector< SireBase::PropPtr< SireMM::Restraint3D > > ( ::SireMM::RestraintFF::*restraints_function_type )( ) const;
restraints_function_type restraints_function_value( &::SireMM::RestraintFF::restraints );
RestraintFF_exposer.def(
"restraints"
, restraints_function_value );
}
{ //::SireMM::RestraintFF::setProperty
typedef bool ( ::SireMM::RestraintFF::*setProperty_function_type )( ::QString const &,::SireBase::Property const & ) ;
setProperty_function_type setProperty_function_value( &::SireMM::RestraintFF::setProperty );
RestraintFF_exposer.def(
"setProperty"
, setProperty_function_value
, ( bp::arg("name"), bp::arg("property") ) );
}
{ //::SireMM::RestraintFF::setSpace
typedef bool ( ::SireMM::RestraintFF::*setSpace_function_type )( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::RestraintFF::setSpace );
RestraintFF_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") ) );
}
{ //::SireMM::RestraintFF::setValue
typedef bool ( ::SireMM::RestraintFF::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ;
setValue_function_type setValue_function_value( &::SireMM::RestraintFF::setValue );
RestraintFF_exposer.def(
"setValue"
, setValue_function_value
, ( bp::arg("symbol"), bp::arg("value") ) );
}
{ //::SireMM::RestraintFF::space
typedef ::SireVol::Space const & ( ::SireMM::RestraintFF::*space_function_type )( ) const;
space_function_type space_function_value( &::SireMM::RestraintFF::space );
RestraintFF_exposer.def(
"space"
, space_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::RestraintFF::symbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireMM::RestraintFF::symbols );
RestraintFF_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireMM::RestraintFF::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::RestraintFF::typeName );
RestraintFF_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::RestraintFF::userSymbols
typedef ::SireCAS::Symbols ( ::SireMM::RestraintFF::*userSymbols_function_type )( ) const;
userSymbols_function_type userSymbols_function_value( &::SireMM::RestraintFF::userSymbols );
RestraintFF_exposer.def(
"userSymbols"
, userSymbols_function_value );
}
{ //::SireMM::RestraintFF::userValues
typedef ::SireCAS::Values ( ::SireMM::RestraintFF::*userValues_function_type )( ) const;
userValues_function_type userValues_function_value( &::SireMM::RestraintFF::userValues );
RestraintFF_exposer.def(
"userValues"
, userValues_function_value );
}
RestraintFF_exposer.staticmethod( "typeName" );
RestraintFF_exposer.def( "__copy__", &__copy__);
RestraintFF_exposer.def( "__deepcopy__", &__copy__);
RestraintFF_exposer.def( "clone", &__copy__);
RestraintFF_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::RestraintFF >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
RestraintFF_exposer.def( "__str__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__repr__", &__str__< ::SireMM::RestraintFF > );
RestraintFF_exposer.def( "__len__", &__len_count< ::SireMM::RestraintFF > );
}
}
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 );
}
}
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 > );
}
}
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 > );
}
}
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 > );
}
}
void register_NullRestraint_class() {
{ //::SireMM::NullRestraint
typedef bp::class_< SireMM::NullRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > NullRestraint_exposer_t;
NullRestraint_exposer_t NullRestraint_exposer = NullRestraint_exposer_t( "NullRestraint", bp::init< >() );
bp::scope NullRestraint_scope( NullRestraint_exposer );
NullRestraint_exposer.def( bp::init< SireMM::NullRestraint const & >(( bp::arg("other") )) );
{ //::SireMM::NullRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::NullRestraint::builtinSymbols );
NullRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::NullRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*builtinValues_function_type )( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::NullRestraint::builtinValues );
NullRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value );
}
{ //::SireMM::NullRestraint::contains
typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::NullRestraint::contains );
NullRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMM::NullRestraint::contains
typedef bool ( ::SireMM::NullRestraint::*contains_function_type )( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::NullRestraint::contains );
NullRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") ) );
}
{ //::SireMM::NullRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::NullRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::NullRestraint::differentiate );
NullRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::energy
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMM::NullRestraint::*energy_function_type )( ) const;
energy_function_type energy_function_value( &::SireMM::NullRestraint::energy );
NullRestraint_exposer.def(
"energy"
, energy_function_value );
}
{ //::SireMM::NullRestraint::force
typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::NullRestraint::force );
NullRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::NullRestraint::force
typedef void ( ::SireMM::NullRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::NullRestraint::force );
NullRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::NullRestraint::getValue
typedef double ( ::SireMM::NullRestraint::*getValue_function_type )( ::SireCAS::Symbol const & ) const;
getValue_function_type getValue_function_value( &::SireMM::NullRestraint::getValue );
NullRestraint_exposer.def(
"getValue"
, getValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::hasValue
typedef bool ( ::SireMM::NullRestraint::*hasValue_function_type )( ::SireCAS::Symbol const & ) const;
hasValue_function_type hasValue_function_value( &::SireMM::NullRestraint::hasValue );
NullRestraint_exposer.def(
"hasValue"
, hasValue_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::NullRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::NullRestraint::*molecules_function_type )( ) const;
molecules_function_type molecules_function_value( &::SireMM::NullRestraint::molecules );
NullRestraint_exposer.def(
"molecules"
, molecules_function_value );
}
NullRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::NullRestraint::operator=
typedef ::SireMM::NullRestraint & ( ::SireMM::NullRestraint::*assign_function_type )( ::SireMM::NullRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::NullRestraint::operator= );
NullRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
NullRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::NullRestraint::setValue
typedef void ( ::SireMM::NullRestraint::*setValue_function_type )( ::SireCAS::Symbol const &,double ) ;
setValue_function_type setValue_function_value( &::SireMM::NullRestraint::setValue );
NullRestraint_exposer.def(
"setValue"
, setValue_function_value
, ( bp::arg("symbol"), bp::arg("value") ) );
}
{ //::SireMM::NullRestraint::symbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*symbols_function_type )( ) const;
symbols_function_type symbols_function_value( &::SireMM::NullRestraint::symbols );
NullRestraint_exposer.def(
"symbols"
, symbols_function_value );
}
{ //::SireMM::NullRestraint::toString
typedef ::QString ( ::SireMM::NullRestraint::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMM::NullRestraint::toString );
NullRestraint_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMM::NullRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::NullRestraint::typeName );
NullRestraint_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::NullRestraint::update
typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::NullRestraint::update );
NullRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMM::NullRestraint::update
typedef void ( ::SireMM::NullRestraint::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::NullRestraint::update );
NullRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::NullRestraint::userSymbols
typedef ::SireCAS::Symbols ( ::SireMM::NullRestraint::*userSymbols_function_type )( ) const;
userSymbols_function_type userSymbols_function_value( &::SireMM::NullRestraint::userSymbols );
NullRestraint_exposer.def(
"userSymbols"
, userSymbols_function_value );
}
{ //::SireMM::NullRestraint::userValues
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*userValues_function_type )( ) const;
userValues_function_type userValues_function_value( &::SireMM::NullRestraint::userValues );
NullRestraint_exposer.def(
"userValues"
, userValues_function_value );
}
{ //::SireMM::NullRestraint::usesMoleculesIn
typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn );
NullRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") ) );
}
{ //::SireMM::NullRestraint::usesMoleculesIn
typedef bool ( ::SireMM::NullRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::NullRestraint::usesMoleculesIn );
NullRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::NullRestraint::values
typedef ::SireCAS::Values ( ::SireMM::NullRestraint::*values_function_type )( ) const;
values_function_type values_function_value( &::SireMM::NullRestraint::values );
NullRestraint_exposer.def(
"values"
, values_function_value );
}
NullRestraint_exposer.staticmethod( "typeName" );
NullRestraint_exposer.def( "__copy__", &__copy__);
NullRestraint_exposer.def( "__deepcopy__", &__copy__);
NullRestraint_exposer.def( "clone", &__copy__);
NullRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::NullRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::NullRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
NullRestraint_exposer.def( "__str__", &__str__< ::SireMM::NullRestraint > );
NullRestraint_exposer.def( "__repr__", &__str__< ::SireMM::NullRestraint > );
}
}
void register_DoubleDistanceRestraint_class(){
{ //::SireMM::DoubleDistanceRestraint
typedef bp::class_< SireMM::DoubleDistanceRestraint, bp::bases< SireMM::Restraint3D, SireMM::Restraint, SireBase::Property > > DoubleDistanceRestraint_exposer_t;
DoubleDistanceRestraint_exposer_t DoubleDistanceRestraint_exposer = DoubleDistanceRestraint_exposer_t( "DoubleDistanceRestraint", bp::init< >() );
bp::scope DoubleDistanceRestraint_scope( DoubleDistanceRestraint_exposer );
DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint") )) );
DoubleDistanceRestraint_exposer.def( bp::init< SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireFF::PointRef const &, SireCAS::Expression const &, SireCAS::Values const & >(( bp::arg("point0"), bp::arg("point1"), bp::arg("point2"), bp::arg("point3"), bp::arg("restraint"), bp::arg("values") )) );
DoubleDistanceRestraint_exposer.def( bp::init< SireMM::DoubleDistanceRestraint const & >(( bp::arg("other") )) );
{ //::SireMM::DoubleDistanceRestraint::builtinSymbols
typedef ::SireCAS::Symbols ( ::SireMM::DoubleDistanceRestraint::*builtinSymbols_function_type )( ) const;
builtinSymbols_function_type builtinSymbols_function_value( &::SireMM::DoubleDistanceRestraint::builtinSymbols );
DoubleDistanceRestraint_exposer.def(
"builtinSymbols"
, builtinSymbols_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::builtinValues
typedef ::SireCAS::Values ( ::SireMM::DoubleDistanceRestraint::*builtinValues_function_type )( ) const;
builtinValues_function_type builtinValues_function_value( &::SireMM::DoubleDistanceRestraint::builtinValues );
DoubleDistanceRestraint_exposer.def(
"builtinValues"
, builtinValues_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::contains
typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolNum ) const;
contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains );
DoubleDistanceRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molnum") ) );
}
{ //::SireMM::DoubleDistanceRestraint::contains
typedef bool ( ::SireMM::DoubleDistanceRestraint::*contains_function_type )( ::SireMol::MolID const & ) const;
contains_function_type contains_function_value( &::SireMM::DoubleDistanceRestraint::contains );
DoubleDistanceRestraint_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("molid") ) );
}
{ //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01
typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction01_function_type )( ) const;
differentialRestraintFunction01_function_type differentialRestraintFunction01_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction01 );
DoubleDistanceRestraint_exposer.def(
"differentialRestraintFunction01"
, differentialRestraintFunction01_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23
typedef ::SireCAS::Expression const & ( ::SireMM::DoubleDistanceRestraint::*differentialRestraintFunction23_function_type )( ) const;
differentialRestraintFunction23_function_type differentialRestraintFunction23_function_value( &::SireMM::DoubleDistanceRestraint::differentialRestraintFunction23 );
DoubleDistanceRestraint_exposer.def(
"differentialRestraintFunction23"
, differentialRestraintFunction23_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMM::DoubleDistanceRestraint::differentiate
typedef ::SireMM::RestraintPtr ( ::SireMM::DoubleDistanceRestraint::*differentiate_function_type )( ::SireCAS::Symbol const & ) const;
differentiate_function_type differentiate_function_value( &::SireMM::DoubleDistanceRestraint::differentiate );
DoubleDistanceRestraint_exposer.def(
"differentiate"
, differentiate_function_value
, ( bp::arg("symbol") ) );
}
{ //::SireMM::DoubleDistanceRestraint::force
typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::MolForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force );
DoubleDistanceRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::DoubleDistanceRestraint::force
typedef void ( ::SireMM::DoubleDistanceRestraint::*force_function_type )( ::SireFF::ForceTable &,double ) const;
force_function_type force_function_value( &::SireMM::DoubleDistanceRestraint::force );
DoubleDistanceRestraint_exposer.def(
"force"
, force_function_value
, ( bp::arg("forcetable"), bp::arg("scale_force")=1 ) );
}
{ //::SireMM::DoubleDistanceRestraint::molecules
typedef ::SireMol::Molecules ( ::SireMM::DoubleDistanceRestraint::*molecules_function_type )( ) const;
molecules_function_type molecules_function_value( &::SireMM::DoubleDistanceRestraint::molecules );
DoubleDistanceRestraint_exposer.def(
"molecules"
, molecules_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::nPoints
typedef int ( ::SireMM::DoubleDistanceRestraint::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireMM::DoubleDistanceRestraint::nPoints );
DoubleDistanceRestraint_exposer.def(
"nPoints"
, nPoints_function_value );
}
DoubleDistanceRestraint_exposer.def( bp::self != bp::self );
{ //::SireMM::DoubleDistanceRestraint::operator=
typedef ::SireMM::DoubleDistanceRestraint & ( ::SireMM::DoubleDistanceRestraint::*assign_function_type )( ::SireMM::DoubleDistanceRestraint const & ) ;
assign_function_type assign_function_value( &::SireMM::DoubleDistanceRestraint::operator= );
DoubleDistanceRestraint_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
DoubleDistanceRestraint_exposer.def( bp::self == bp::self );
{ //::SireMM::DoubleDistanceRestraint::point
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point_function_type )( int ) const;
point_function_type point_function_value( &::SireMM::DoubleDistanceRestraint::point );
DoubleDistanceRestraint_exposer.def(
"point"
, point_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point0
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point0_function_type )( ) const;
point0_function_type point0_function_value( &::SireMM::DoubleDistanceRestraint::point0 );
DoubleDistanceRestraint_exposer.def(
"point0"
, point0_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point1
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point1_function_type )( ) const;
point1_function_type point1_function_value( &::SireMM::DoubleDistanceRestraint::point1 );
DoubleDistanceRestraint_exposer.def(
"point1"
, point1_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point2
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point2_function_type )( ) const;
point2_function_type point2_function_value( &::SireMM::DoubleDistanceRestraint::point2 );
DoubleDistanceRestraint_exposer.def(
"point2"
, point2_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::point3
typedef ::SireFF::Point const & ( ::SireMM::DoubleDistanceRestraint::*point3_function_type )( ) const;
point3_function_type point3_function_value( &::SireMM::DoubleDistanceRestraint::point3 );
DoubleDistanceRestraint_exposer.def(
"point3"
, point3_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::r01
typedef ::SireCAS::Symbol const & ( *r01_function_type )( );
r01_function_type r01_function_value( &::SireMM::DoubleDistanceRestraint::r01 );
DoubleDistanceRestraint_exposer.def(
"r01"
, r01_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::r23
typedef ::SireCAS::Symbol const & ( *r23_function_type )( );
r23_function_type r23_function_value( &::SireMM::DoubleDistanceRestraint::r23 );
DoubleDistanceRestraint_exposer.def(
"r23"
, r23_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMM::DoubleDistanceRestraint::setSpace
typedef void ( ::SireMM::DoubleDistanceRestraint::*setSpace_function_type )( ::SireVol::Space const & ) ;
setSpace_function_type setSpace_function_value( &::SireMM::DoubleDistanceRestraint::setSpace );
DoubleDistanceRestraint_exposer.def(
"setSpace"
, setSpace_function_value
, ( bp::arg("space") ) );
}
{ //::SireMM::DoubleDistanceRestraint::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMM::DoubleDistanceRestraint::typeName );
DoubleDistanceRestraint_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMM::DoubleDistanceRestraint::update
typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update );
DoubleDistanceRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
{ //::SireMM::DoubleDistanceRestraint::update
typedef void ( ::SireMM::DoubleDistanceRestraint::*update_function_type )( ::SireMol::Molecules const & ) ;
update_function_type update_function_value( &::SireMM::DoubleDistanceRestraint::update );
DoubleDistanceRestraint_exposer.def(
"update"
, update_function_value
, ( bp::arg("molecules") ) );
}
{ //::SireMM::DoubleDistanceRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireFF::ForceTable const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn );
DoubleDistanceRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("forcetable") ) );
}
{ //::SireMM::DoubleDistanceRestraint::usesMoleculesIn
typedef bool ( ::SireMM::DoubleDistanceRestraint::*usesMoleculesIn_function_type )( ::SireMol::Molecules const & ) const;
usesMoleculesIn_function_type usesMoleculesIn_function_value( &::SireMM::DoubleDistanceRestraint::usesMoleculesIn );
DoubleDistanceRestraint_exposer.def(
"usesMoleculesIn"
, usesMoleculesIn_function_value
, ( bp::arg("molecules") ) );
}
DoubleDistanceRestraint_exposer.staticmethod( "r01" );
DoubleDistanceRestraint_exposer.staticmethod( "r23" );
DoubleDistanceRestraint_exposer.staticmethod( "typeName" );
DoubleDistanceRestraint_exposer.def( "__copy__", &__copy__);
DoubleDistanceRestraint_exposer.def( "__deepcopy__", &__copy__);
DoubleDistanceRestraint_exposer.def( "clone", &__copy__);
DoubleDistanceRestraint_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::DoubleDistanceRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleDistanceRestraint_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::DoubleDistanceRestraint >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
DoubleDistanceRestraint_exposer.def( "__str__", &__str__< ::SireMM::DoubleDistanceRestraint > );
DoubleDistanceRestraint_exposer.def( "__repr__", &__str__< ::SireMM::DoubleDistanceRestraint > );
}
}
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 > );
}
}
