analyzer.h

Go to the documentation of this file.

/*************************************************************************************
 *  Copyright (C) 2007-2010 by Aleix Pol <aleixpol@kde.org>                          *
 *                                                                                   *
 *  This program is free software; you can redistribute it and/or                    *
 *  modify it under the terms of the GNU General Public License                      *
 *  as published by the Free Software Foundation; either version 2                   *
 *  of the License, or (at your option) any later version.                           *
 *                                                                                   *
 *  This program is distributed in the hope that it will be useful,                  *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of                   *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                    *
 *  GNU General Public License for more details.                                     *
 *                                                                                   *
 *  You should have received a copy of the GNU General Public License                *
 *  along with this program; if not, write to the Free Software                      *
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA   *
 *************************************************************************************/


#ifndef ANALYZER_H
#define ANALYZER_H

#include <QStringList>

#include "expression.h"
#include "analitzaexport.h"
#include "expressiontype.h"
#include "builtinmethods.h"
#include <QStack>
#include <analitza/analitzautils.h>

namespace Analitza
{
class Polynomial;
class Monomial;
class Apply;
class BoundingIterator;
class BuiltinMethods;
class Object;
class Variables;
class Container;
class Operator;
class Ci;

class ANALITZA_EXPORT Analyzer
{
    public:
        Analyzer();
        
        Analyzer(Variables* v);
        
        Analyzer(const Analyzer& a);
        
        ~Analyzer();
        
        void setExpression(const Expression &e);
        
        const Expression& expression() const { return m_exp; }
        
        Expression calculate();
        
        Expression calculateLambda();
        
        Expression evaluate();
        
        Expression derivative(const QString& var);
        
        double derivative(const QVector<Object*>& values );
        
        bool isCorrect() const { return m_err.isEmpty() && m_exp.isCorrect(); }
        
        void flushErrors() { m_err.clear(); }
        
        void simplify(); //FIXME: Should return an Expression
        
        QStringList errors() const { return m_exp.error() + m_err; }
        
        Variables *variables() const { return m_vars; }
        
        bool insertVariable(const QString& name, const Expression& value);
        
        bool insertVariable(const QString& name, const Object* value);
        
        Cn* insertValueVariable(const QString& name, double value);
        
        bool hasDependencies() const { return m_hasdeps; }
        
        Expression dependenciesToLambda() const;
        
        ExpressionType type() const { return m_currentType; }
        
        void setStack(const QVector<Object*>& stack) { m_runStack = stack; }
        
        QVector<Object*> runStack() const { return m_runStack; }
        
        BuiltinMethods* builtinMethods();
        
        void importScript(QTextStream* stream);
        
        QMap<QString, ExpressionType> variableTypes() const { return m_variablesTypes; }
    private:
        typedef Object* (Analyzer::*funcContainer)(const Container*);
        static funcContainer operateContainer[];
        
        Expression m_exp;
        Variables *m_vars;
        QStringList m_err;
        QVector<Object*> m_runStack;
        int m_runStackTop;
        BuiltinMethods m_builtin;
        
        const bool m_varsOwned;
        bool m_hasdeps;
        ExpressionType m_currentType;
        QMap<QString, ExpressionType> m_variablesTypes;
        
        Object* calc(const Object* e);
        Object* operate(const Container*);
        Object* operate(const Apply*);
        Object* eval(const Object* e, bool vars, const QSet<QString>& unscoped);
        
        Object* sum(const Apply& c);
        Object* product(const Apply& c);
        Object* exists(const Apply& c);
        Object* forall(const Apply& c);
        Object* func(const Apply& c);
        Object* calcDiff(const Apply* c);
        Object* calcMap(const Apply* c);
        Object* calcFilter(const Apply* c);
        
        Object* calcPiecewise(const Container* c);
        Object* calcDeclare(const Container* c);
        Object* calcMath(const Container* c);
        Object* calcLambda(const Container* c);
        Object* calcCallFunction(Analitza::Container* function, const QVector<Analitza::Object* >& args, const Analitza::Object* op);
        
        Object* simp(Object* root);
        Object* simpPolynomials(Apply* c);
        Object* simpSum(Apply* c);
        Object* simpApply(Apply* c);
        Object* simpPiecewise(Container* c);
        
        QList<Object*> findRoots(const QString& dep, const Analitza::Object* o);
        QList<Object*> findRootsApply(const QString& dep, const Analitza::Apply* a);
        
        Object* derivative(const QString &var, const Object*);
        Object* boundedOperation(const Apply & n, const Operator & t, Object* initial);
        
        BoundingIterator* initializeBVars(const Apply* n, int base);
        BoundingIterator* initBVarsContainer(const Apply* n, int base, Object* domain);
        BoundingIterator* initBVarsRange(const Apply* n, int base, Object* dlimit, Object* ulimit);
        
        template <class T, class Tit>
        void iterateAndSimp(T* v);
        
        Object* variableValue(Ci* var);
        Object* testResult(const Analitza::Object* o, const QString& var, const Analitza::Object* val);
        
        template <class T, class Tit>
        void alphaConversion(T* o, int min);
        void alphaConversion(Apply* a, int min);
        void alphaConversion(Container* a, int min);
        Object* applyAlpha(Analitza::Object* o, int min);
        
        template<class T, class Tit>
        Object* calcElements(const Analitza::Object* root, T* nv);
};

}
#endif