void register_LessThan_class(){
{ //::SireCAS::LessThan
typedef bp::class_< SireCAS::LessThan, bp::bases< SireCAS::Condition, SireCAS::ExBase > > LessThan_exposer_t;
LessThan_exposer_t LessThan_exposer = LessThan_exposer_t( "LessThan", bp::init< >() );
bp::scope LessThan_scope( LessThan_exposer );
LessThan_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("left_hand_side"), bp::arg("right_hand_side") )) );
LessThan_exposer.def( bp::init< SireCAS::LessThan const & >(( bp::arg("other") )) );
{ //::SireCAS::LessThan::alwaysFalse
typedef bool ( ::SireCAS::LessThan::*alwaysFalse_function_type )( ) const;
alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::LessThan::alwaysFalse );
LessThan_exposer.def(
"alwaysFalse"
, alwaysFalse_function_value );
}
{ //::SireCAS::LessThan::alwaysTrue
typedef bool ( ::SireCAS::LessThan::*alwaysTrue_function_type )( ) const;
alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::LessThan::alwaysTrue );
LessThan_exposer.def(
"alwaysTrue"
, alwaysTrue_function_value );
}
{ //::SireCAS::LessThan::operator=
typedef ::SireCAS::LessThan & ( ::SireCAS::LessThan::*assign_function_type )( ::SireCAS::LessThan const & ) ;
assign_function_type assign_function_value( &::SireCAS::LessThan::operator= );
LessThan_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
LessThan_exposer.def( bp::self == bp::self );
LessThan_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
{ //::SireCAS::LessThan::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::LessThan::typeName );
LessThan_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireCAS::LessThan::what
typedef char const * ( ::SireCAS::LessThan::*what_function_type )( ) const;
what_function_type what_function_value( &::SireCAS::LessThan::what );
LessThan_exposer.def(
"what"
, what_function_value );
}
LessThan_exposer.staticmethod( "typeName" );
LessThan_exposer.def( "__copy__", &__copy__);
LessThan_exposer.def( "__deepcopy__", &__copy__);
LessThan_exposer.def( "clone", &__copy__);
LessThan_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::LessThan >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LessThan_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::LessThan >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
LessThan_exposer.def( "__str__", &__str__< ::SireCAS::LessThan > );
LessThan_exposer.def( "__repr__", &__str__< ::SireCAS::LessThan > );
}
}
void register_GreaterOrEqualThan_class(){
{ //::SireCAS::GreaterOrEqualThan
typedef bp::class_< SireCAS::GreaterOrEqualThan, bp::bases< SireCAS::Condition, SireCAS::ExBase > > GreaterOrEqualThan_exposer_t;
GreaterOrEqualThan_exposer_t GreaterOrEqualThan_exposer = GreaterOrEqualThan_exposer_t( "GreaterOrEqualThan", "This is a conditional function that returns whether or\nnot the first expression is greater than or equal to\nthe second expression\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope GreaterOrEqualThan_scope( GreaterOrEqualThan_exposer );
GreaterOrEqualThan_exposer.def( bp::init< SireCAS::Expression const &, SireCAS::Expression const & >(( bp::arg("left_hand_side"), bp::arg("right_hand_side") ), "Construct to compare left_hand_side with right_hand_side") );
GreaterOrEqualThan_exposer.def( bp::init< SireCAS::GreaterOrEqualThan const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireCAS::GreaterOrEqualThan::alwaysFalse
typedef bool ( ::SireCAS::GreaterOrEqualThan::*alwaysFalse_function_type)( ) const;
alwaysFalse_function_type alwaysFalse_function_value( &::SireCAS::GreaterOrEqualThan::alwaysFalse );
GreaterOrEqualThan_exposer.def(
"alwaysFalse"
, alwaysFalse_function_value
, "Return whether or not we can be absolutely sure that this\ncondition will always be false. Note that this doesnt try\ntoo hard, so some things that are always false may not\nbe reported here as being always false, e.g. x > x + 1" );
}
{ //::SireCAS::GreaterOrEqualThan::alwaysTrue
typedef bool ( ::SireCAS::GreaterOrEqualThan::*alwaysTrue_function_type)( ) const;
alwaysTrue_function_type alwaysTrue_function_value( &::SireCAS::GreaterOrEqualThan::alwaysTrue );
GreaterOrEqualThan_exposer.def(
"alwaysTrue"
, alwaysTrue_function_value
, "Return whether or not we can be absolutely sure that this\ncondition will always be true. Note that this doesnt try\ntoo hard, so some things that are always true may not\nbe reported here as being always true, e.g. x + 1 > x" );
}
{ //::SireCAS::GreaterOrEqualThan::operator=
typedef ::SireCAS::GreaterOrEqualThan & ( ::SireCAS::GreaterOrEqualThan::*assign_function_type)( ::SireCAS::GreaterOrEqualThan const & ) ;
assign_function_type assign_function_value( &::SireCAS::GreaterOrEqualThan::operator= );
GreaterOrEqualThan_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
GreaterOrEqualThan_exposer.def( bp::self == bp::self );
GreaterOrEqualThan_exposer.def( bp::self == bp::other< SireCAS::ExBase >() );
{ //::SireCAS::GreaterOrEqualThan::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireCAS::GreaterOrEqualThan::typeName );
GreaterOrEqualThan_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireCAS::GreaterOrEqualThan::what
typedef char const * ( ::SireCAS::GreaterOrEqualThan::*what_function_type)( ) const;
what_function_type what_function_value( &::SireCAS::GreaterOrEqualThan::what );
GreaterOrEqualThan_exposer.def(
"what"
, what_function_value
, "" );
}
GreaterOrEqualThan_exposer.staticmethod( "typeName" );
GreaterOrEqualThan_exposer.def( "__copy__", &__copy__);
GreaterOrEqualThan_exposer.def( "__deepcopy__", &__copy__);
GreaterOrEqualThan_exposer.def( "clone", &__copy__);
GreaterOrEqualThan_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::GreaterOrEqualThan >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GreaterOrEqualThan_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::GreaterOrEqualThan >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GreaterOrEqualThan_exposer.def( "__str__", &__str__< ::SireCAS::GreaterOrEqualThan > );
GreaterOrEqualThan_exposer.def( "__repr__", &__str__< ::SireCAS::GreaterOrEqualThan > );
GreaterOrEqualThan_exposer.def( "__hash__", &::SireCAS::GreaterOrEqualThan::hash );
}
}
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 > );
}
}