Expression.h

#pragma once
 
#include "DefinitionsMathematics.h"
#include "Equation.h"
 
#include <vector>
#include <complex>
#include <functional>
 
namespace FLImaging
{
    namespace Foundation
    {
        class FL_EXPORT CExpression : public Base::CFLBase
        {
        public:
 
            CExpression();
 
            CExpression(const CExpression& rhs);
 
            CExpression(const CExpression* pRhs);
 
            CExpression(const wchar_t* pWcsExpression);
 
            virtual ~CExpression();
 
            const CResult Clear();
 
            const CResult Assign(const CExpression& rhs);
 
            const CResult Assign(const CExpression* pRhs);
 
            const CResult SetExpression(const wchar_t* pWcsExpression);
 
            const wchar_t* GetExpression();
 
            Base::CFLString<wchar_t> GetExpression(bool bExponentialNotation, int32_t i32CoeffPrecision);
 
            const CResult Evaluate(wchar_t** ppWcsEvaluatorExpression = nullptr);
 
            const CResult Solve(const wchar_t* pWcsVariable, Base::CFLArray<std::complex<double>>* pFlaResult, ECoefficientOrder eCoeffOrder = ECoefficientOrder_Ascending, EAccuracy eAccuracy = EAccuracy_Bits64);
 
            const CResult Solve(const wchar_t* pWcsVariable, Base::CFLArray<std::complex<double>>* pFlaResult, Base::CFLArray<std::complex<double>>* pFlaDiscontinuous, ECoefficientOrder eCoeffOrder = ECoefficientOrder_Ascending, EAccuracy eAccuracy = EAccuracy_Bits64);
 
            const CResult ExpandExpression(wchar_t** ppWcsEvaluatorExpression = nullptr);
 
            const CResult UnrollPower(wchar_t** ppWcsEvaluatorExpression = nullptr);
 
            const CResult CollectExpression(wchar_t** ppWcsEvaluatorExpression = nullptr);
 
            int32_t GetVariableCount();
 
            int32_t GetIndexOfVariable(const wchar_t* pWcsVariableName);
 
            int32_t GetIndexOfEvaluatedVariable(const wchar_t* pWcsVariableName);
 
            const CResult AssignVariable(int32_t i32Index, double f64Value);
 
            const CResult AssignVariable(const wchar_t* pWcsVariableName, double f64Value);
 
            const CResult ResetVariable(int32_t i32Index);
 
            const CResult ResetVariable(const wchar_t* pWcsVariableName);
 
            double* GetVariable(int32_t i32Index);
 
            double* GetVariable(const wchar_t* pWcsVariableName);
 
            const double GetEvaluatedVariable(int32_t i32Index);
 
            const double GetEvaluatedVariable(const wchar_t* pWcsVariableName);
 
            CExpression Differentiate(const wchar_t* pWcsVariableName);
            CExpression Differentiate();
// 
//          CExpression Integrate(const wchar_t* pWcsVariableName);
//          CExpression Integrate();
 
            enum EExpressionValid
            {
                EExpressionValid_Initialized = 0,
 
                EExpressionValid_Valid,
 
                EExpressionValid_Invalid,
            };
 
            EExpressionValid IsExprssionValid();
 
            const CResult GetExpression(std::function<double(double)>* pExpression);
 
 
            SupportToDuplicateObject(CExpression, *this);
            DeclareGetClassType();
 
        protected:
            wchar_t* m_pWcsExpression;
            std::vector<std::pair<Base::CFLString<wchar_t>, double> >* m_pVctVariables;
            std::vector<std::pair<Base::CFLString<wchar_t>, double> >* m_pVctEvaluatedVariables;
            EExpressionValid m_eExpressionValid;
        };
    }
}