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

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

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

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

}