functions.h

/***************************************************************************
 *   Copyright (C) 2004-2006 by Radko Mihal                                *
 *   rmihal@pobox.sk                                                       *
 *                                                                         *
 *   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 St, Fifth Floor, Boston, MA 02110-1301, USA.              *
 ***************************************************************************/
#ifndef FUNCTIONS_H
#define FUNCTIONS_H

#include "acos.h"
#include "asin.h"
#include "atan.h"
#include "ceil.h"
#include "cos.h"
#include "cosh.h"
#include "exp.h"
#include "fabs.h"
#include "floor.h"
#include "fmod.h"
#include "ldexp.h"
#include "log.h"
#include "sin.h"
#include "sinh.h"
#include "sqrt.h"
#include "tan.h"
#include "tanh.h"
#include "pow_class.h"

template< class Type > class expression;

template< class Type >
class functions  
{
        grammar_to_parser::non_terminal< acos_class< Type > >           m_acos;
        grammar_to_parser::non_terminal< asin_class< Type > >           m_asin;
        grammar_to_parser::non_terminal< atan_class< Type > >           m_atan;
        grammar_to_parser::non_terminal< ceil_class< Type > >           m_ceil;
        grammar_to_parser::non_terminal< cos_class< Type > >            m_cos;
        grammar_to_parser::non_terminal< cosh_class< Type > >           m_cosh;
        grammar_to_parser::non_terminal< exp_class< Type > >            m_exp;
        grammar_to_parser::non_terminal< fabs_class< Type > >           m_fabs;
        grammar_to_parser::non_terminal< floor_class< Type > >          m_floor;
        grammar_to_parser::non_terminal< fmod_class< Type > >           m_fmod;
        grammar_to_parser::non_terminal< ldexp_class< Type > >          m_ldexp;
        grammar_to_parser::non_terminal< log_class< Type > >            m_log;
        grammar_to_parser::non_terminal< sin_class< Type > >            m_sin;
        grammar_to_parser::non_terminal< sinh_class< Type > >           m_sinh;
        grammar_to_parser::non_terminal< sqrt_class< Type > >           m_sqrt;
        grammar_to_parser::non_terminal< tan_class< Type > >            m_tan;
        grammar_to_parser::non_terminal< tanh_class< Type > >           m_tanh;
        grammar_to_parser::non_terminal< pow_class< Type > >            m_pow;

public:
        
        functions() {};
        ~functions() {};
        
        void push_parsers( grammar_to_parser::parsers &l )
        {
                l.push_back( &m_pow );
                l.push_back( &m_acos );
                l.push_back( &m_asin );
                l.push_back( &m_atan );
                l.push_back( &m_ceil );
                l.push_back( &m_cos );
                l.push_back( &m_cosh );
                l.push_back( &m_exp );
                l.push_back( &m_fabs );
                l.push_back( &m_floor );
                l.push_back( &m_fmod );
                l.push_back( &m_ldexp );
                l.push_back( &m_log );
                l.push_back( &m_sin );
                l.push_back( &m_sinh );
                l.push_back( &m_sqrt );
                l.push_back( &m_tan );
                l.push_back( &m_tanh );
        }
        Type evaluate()
        {
                if( m_pow.is_parsed() ) return m_pow->evaluate();
                if( m_acos.is_parsed() ) return m_acos->evaluate();
                if( m_asin.is_parsed() ) return m_asin->evaluate();
                if( m_atan.is_parsed() ) return m_atan->evaluate();
                if( m_ceil.is_parsed() ) return m_ceil->evaluate();
                if( m_cos.is_parsed() ) return m_cos->evaluate();
                if( m_cosh.is_parsed() ) return m_cosh->evaluate();
                if( m_exp.is_parsed() ) return m_exp->evaluate();
                if( m_fabs.is_parsed() ) return m_fabs->evaluate();
                if( m_floor.is_parsed() ) return m_floor->evaluate();
                if( m_fmod.is_parsed() ) return m_fmod->evaluate();
                if( m_ldexp.is_parsed() ) return m_ldexp->evaluate();
                if( m_log.is_parsed() ) return m_log->evaluate();
                if( m_sin.is_parsed() ) return m_sin->evaluate();
                if( m_sinh.is_parsed() ) return m_sinh->evaluate();
                if( m_sqrt.is_parsed() ) return m_sqrt->evaluate();
                if( m_tan.is_parsed() ) return m_tan->evaluate();
                if( m_tanh.is_parsed() ) return m_tanh->evaluate();
                return 0;
        }
        
        int get_priority() { return 1; }

};

#endif

---