| 0,0 → 1,238 |
|---|
| |
| #ifndef __mathuserfunc_h__ |
| #define __mathuserfunc_h__ |
| |
| #include "yacasbase.h" |
| #include "lispuserfunc.h" |
| #include "grower.h" |
| |
| #include "patternclass.h" |
| |
| /// A mathematical function defined by several rules. |
| /// This is the basic class which implements functions in Yacas. |
| /// Evaluation is done by consulting a set of rewriting rules. The |
| /// body of the first rule that matches, is evaluated and this gives |
| /// the result of evaluating the function. |
| |
| class BranchingUserFunction : public LispArityUserFunction |
| { |
| public: |
| /// Structure containing name of parameter and whether it is put on hold. |
| class BranchParameter : public YacasBase |
| { |
| public: |
| BranchParameter(LispString * aParameter = NULL, LispInt aHold=LispFalse) |
| : iParameter(aParameter), iHold(aHold) {} |
| LispString * iParameter; |
| LispInt iHold; |
| }; |
| |
| /// Abstract base class for rules. |
| class BranchRuleBase : public YacasBase |
| { |
| public: |
| virtual ~BranchRuleBase(); |
| virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments) = 0; |
| virtual LispInt Precedence() const = 0; |
| virtual LispPtr& Body() = 0; |
| }; |
| |
| /// A rule with a predicate. |
| /// This rule matches if the predicate evaluates to #LispTrue. |
| class BranchRule : public BranchRuleBase |
| { |
| public: |
| virtual ~BranchRule(); |
| BranchRule(LispInt aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate) |
| { |
| } |
| |
| /// Return true if the rule matches. |
| /// #iPredicate is evaluated in \a Environment. If the result |
| /// IsTrue(), this function returns true. |
| virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments); |
| |
| /// Access #iPrecedence. |
| virtual LispInt Precedence() const; |
| |
| /// Access #iBody. |
| virtual LispPtr& Body(); |
| protected: |
| BranchRule() : iPrecedence(0),iBody(),iPredicate() {}; |
| protected: |
| LispInt iPrecedence; |
| LispPtr iBody; |
| LispPtr iPredicate; |
| }; |
| |
| /// A rule that always matches. |
| class BranchRuleTruePredicate : public BranchRule |
| { |
| public: |
| BranchRuleTruePredicate(LispInt aPrecedence,LispPtr& aBody) |
| { |
| iPrecedence = aPrecedence; |
| iBody = (aBody); |
| } |
| /// Return #LispTrue, always. |
| virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments); |
| }; |
| |
| /// A rule which matches if the corresponding PatternClass matches. |
| class BranchPattern : public BranchRuleBase |
| { |
| public: |
| /// Destructor. |
| /// This function contains no code. |
| virtual ~BranchPattern(); |
| |
| /// Constructor. |
| /// \param aPrecedence precedence of the rule |
| /// \param aPredicate generic object of type \c Pattern |
| /// \param aBody body of the rule |
| BranchPattern(LispInt aPrecedence,LispPtr& aPredicate,LispPtr& aBody) : iPrecedence(aPrecedence),iBody(aBody),iPredicate(aPredicate),iPatternClass(NULL) |
| { |
| GenericClass *gen = aPredicate->Generic(); |
| DYNCAST(PatternClass,"\"Pattern\"",pat,gen) |
| Check(pat,KLispErrInvalidArg); |
| iPatternClass = pat; |
| } |
| |
| /// Return true if the corresponding pattern matches. |
| virtual LispBoolean Matches(LispEnvironment& aEnvironment, LispPtr* aArguments); |
| |
| /// Access #iPrecedence |
| virtual LispInt Precedence() const; |
| |
| /// Access #iBody |
| virtual LispPtr& Body(); |
| |
| private: |
| BranchPattern(const BranchPattern& aOther) : iPrecedence(0),iBody(),iPredicate(),iPatternClass(NULL) |
| { |
| // copy constructor not written yet, hence the assert |
| LISPASSERT(0); |
| } |
| BranchPattern& operator=(const BranchPattern& aOther) |
| { |
| // copy constructor not written yet, hence the assert |
| LISPASSERT(0); |
| return *this; |
| } |
| |
| protected: |
| /// The precedence of this rule. |
| LispInt iPrecedence; |
| |
| /// The body of this rule. |
| LispPtr iBody; |
| |
| /// Generic object of type \c Pattern containing #iPatternClass |
| LispPtr iPredicate; |
| |
| /// The pattern that decides whether this rule matches. |
| PatternClass *iPatternClass; |
| }; |
| |
| /// Constructor. |
| /// \param aParameters linked list constaining the names of the arguments |
| /// |
| /// #iParamList and #iParameters are set from \a aParameters. |
| BranchingUserFunction(LispPtr& aParameters); |
| |
| /// Destructor. |
| /// There is no code inside this function. |
| virtual ~BranchingUserFunction(); |
| |
| /// Evaluate the function on given arguments. |
| /// \param aResult (on output) the result of the evaluation |
| /// \param aEnvironment the underlying Lisp environment |
| /// \param aArguments the arguments to the function |
| /// |
| /// First, all arguments are evaluated by the evaluator associated |
| /// to \a aEnvironment, unless the \c iHold flag of the |
| /// corresponding parameter is true. Then a new LispLocalFrame is |
| /// constructed, in which the actual arguments are assigned to the |
| /// names of the formal arguments, as stored in \c iParameter. Then |
| /// all rules in #iRules are tried one by one. The body of the |
| /// first rule that matches is evaluated, and the result is put in |
| /// \a aResult. If no rule matches, \a aResult will recieve a new |
| /// expression with evaluated arguments. |
| virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments); |
| |
| /// Put an argument on hold. |
| /// \param aVariable name of argument to put un hold |
| /// |
| /// The \c iHold flag of the corresponding argument is set. This |
| /// implies that this argument is not evaluated by Evaluate(). |
| virtual void HoldArgument(LispString * aVariable); |
| |
| /// Return true if the arity of the function equals \a aArity. |
| virtual LispInt IsArity(LispInt aArity) const; |
| |
| /// Return the arity (number of arguments) of the function. |
| LispInt Arity() const; |
| |
| /// Add a BranchRule to the list of rules. |
| /// \sa InsertRule() |
| virtual void DeclareRule(LispInt aPrecedence, LispPtr& aPredicate, LispPtr& aBody); |
| |
| /// Add a BranchRuleTruePredicate to the list of rules. |
| /// \sa InsertRule() |
| virtual void DeclareRule(LispInt aPrecedence, LispPtr& aBody); |
| |
| /// Add a BranchPattern to the list of rules. |
| /// \sa InsertRule() |
| void DeclarePattern(LispInt aPrecedence, LispPtr& aPredicate, LispPtr& aBody); |
| |
| /// Insert any BranchRuleBase object in the list of rules. |
| /// This function does the real work for DeclareRule() and |
| /// DeclarePattern(): it inserts the rule in #iRules, while |
| /// keeping it sorted. The algorithm is \f$O(\log n)\f$, where |
| /// \f$n\f$ denotes the number of rules. |
| void InsertRule(LispInt aPrecedence,BranchRuleBase* newRule); |
| |
| /// Return the argument list, stored in #iParamList |
| virtual LispPtr& ArgList(); |
| |
| protected: |
| /// List of arguments, with corresponding \c iHold property. |
| CArrayGrower<BranchParameter, ArrOpsPOD<BranchParameter> > iParameters; |
| |
| /// List of rules, sorted on precedence. |
| CDeletingArrayGrower<BranchRuleBase*, ArrOpsDeletingPtr<BranchRuleBase> > iRules; |
| |
| /// List of arguments |
| LispPtr iParamList; |
| }; |
| |
| class ListedBranchingUserFunction : public BranchingUserFunction |
| { |
| public: |
| ListedBranchingUserFunction(LispPtr& aParameters); |
| virtual LispInt IsArity(LispInt aArity) const; |
| virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments); |
| }; |
| |
| |
| class MacroUserFunction : public BranchingUserFunction |
| { |
| public: |
| MacroUserFunction(LispPtr& aParameters); |
| virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments); |
| }; |
| |
| |
| class ListedMacroUserFunction : public MacroUserFunction |
| { |
| public: |
| ListedMacroUserFunction(LispPtr& aParameters); |
| virtual LispInt IsArity(LispInt aArity) const; |
| virtual void Evaluate(LispPtr& aResult,LispEnvironment& aEnvironment, LispPtr& aArguments); |
| }; |
| |
| |
| |
| |
| #endif |
| |