ope_eq.hpp

/*
    Copyright 2017 Philippe Grandclement
 
    This file is part of Kadath.
 
    Kadath 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 3 of the License, or
    (at your option) any later version.
 
    Kadath 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 Kadath.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef __OPE_EQ_HPP_
#define __OPE_EQ_HPP_
 
#include "term_eq.hpp"
namespace Kadath {
 
    class Ope_eq : public Memory_mapped {
 
        protected:
            const System_of_eqs* syst ; 
            int dom ; 
            int n_ope ; 
            MMPtr_array<Ope_eq> parts ; 
            Ope_eq (const System_of_eqs* syst, int dom, int np = 0) ;
            Ope_eq (const Ope_eq&) = delete; 
        public:
            virtual ~Ope_eq() ; 
 
            int get_dom() const {return dom; } ;
 
            virtual Term_eq action() const = 0;
    } ;
 
    inline Ope_eq::Ope_eq(const System_of_eqs* zesys, int dd, int nn) :
        syst{zesys}, dom{dd}, n_ope{nn}, parts{n_ope,initialize}
    {}
 
    inline Ope_eq::~Ope_eq() {for(auto & x : parts) safe_delete(x);}
 
class Ope_id : public Ope_eq {
 
    protected:
        const Term_eq* target ; 
        int valence ; 
        char* name_ind ; 
        Array<int>* type_ind ; 
        bool need_sum ; 
 
    public:
        Ope_id (const System_of_eqs* syst, const Term_eq* so, int valence, char* names, Array<int>* ttype) ;
        Ope_id (const System_of_eqs* syst, const Term_eq* so) ;
        ~Ope_id() override; 
    public:
        Term_eq action() const override;
} ;
 
 
class Ope_pow : public Ope_eq {
 
    protected:
        int power ; 
    public:
        Ope_pow(const System_of_eqs* syst, int pow, Ope_eq* so) ;
        ~Ope_pow() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_minus : public Ope_eq {
 
    public:
        Ope_minus(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_minus() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_add : public Ope_eq {
 
    public:
        Ope_add(const System_of_eqs* syst, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_add() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_sub : public Ope_eq {
 
    public:
        Ope_sub(const System_of_eqs* syst, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_sub() override ;
    
        Term_eq action() const override;
} ;
 
class Ope_mult : public Ope_eq {
 
    public:
        Ope_mult(const System_of_eqs* syst, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_mult() override ;
    
        Term_eq action() const override;
} ;
 
class Ope_div: public Ope_eq {
 
    public:
        Ope_div(const System_of_eqs* syst, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_div() override ;
    
        Term_eq action() const override;
} ;
 
class Ope_lap: public Ope_eq {
  
    public:
        Ope_lap(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_lap() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_dtime: public Ope_eq {
  
    public:
        Ope_dtime(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_dtime() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_ddtime: public Ope_eq {
 
    public:
        Ope_ddtime(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_ddtime() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_lap2: public Ope_eq {
  
    public:
        Ope_lap2(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_lap2() override ;
    
        Term_eq action() const override;
} ;
 
class Ope_dn: public Ope_eq {
 
    protected:
        int bound ; 
 
    public:
        Ope_dn(const System_of_eqs* syst, int bb, Ope_eq* so) ;
        ~Ope_dn() override ;
    
        Term_eq action() const override;
} ;
 
class Ope_grad: public Ope_eq {
 
    public: 
        Ope_grad(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_grad() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_scal: public Ope_eq {
 
    public:
        Ope_scal(const System_of_eqs* syst, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_scal() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_der: public Ope_eq {
 
    protected:
        int type_der ; 
        char ind_der ; 
 
    public:
        Ope_der(const System_of_eqs* syst, int typeder, char indder, Ope_eq* so) ;
        ~Ope_der() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_der_flat: public Ope_eq {
 
    protected:
        int type_der ;
        char ind_der ;
 
    public:
        Ope_der_flat(const System_of_eqs* syst, int typeder, char indder, Ope_eq* so) ;
        ~Ope_der_flat() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_der_background: public Ope_eq {
 
    protected:
        int type_der ;
        char ind_der ;
 
    public:
        Ope_der_background(const System_of_eqs* syst, int typeder, char indder, Ope_eq* so) ;
        ~Ope_der_background() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_int: public Ope_eq {
 
    protected:
        int bound ; 
 
    public:
        Ope_int(const System_of_eqs* syst, int bb, Ope_eq* so) ;
        ~Ope_int() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_int_volume: public Ope_eq {
 
    public:
        Ope_int_volume (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_int_volume() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_def: public Ope_eq {
    protected:
        Term_eq* res ; 
    public:
        Ope_def (const System_of_eqs* syst, Ope_eq* so, int val, char* name, Array<int>* ttype) ;
        ~Ope_def() override ;
        Term_eq action() const override;
        Term_eq* get_res() ; 
        void compute_res() ; 
} ;
 
class Ope_mult_r: public Ope_eq {
 
    public:
        Ope_mult_r (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_mult_r() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_mult_x: public Ope_eq {
 
    public:
        Ope_mult_x (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_mult_x() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_srdr: public Ope_eq {
 
    public:
        Ope_srdr (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_srdr() override ; 
    
        Term_eq action() const override;
} ;
 
 
 
class Ope_ddr: public Ope_eq {
 
    public:
        Ope_ddr (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_ddr() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_dr: public Ope_eq {
 
    public:
        Ope_dr (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_dr() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_ddp: public Ope_eq {
 
    public:
        Ope_ddp (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_ddp() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_dt: public Ope_eq {
 
    public:
        Ope_dt (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_dt() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_ddt: public Ope_eq {
 
    public:
        Ope_ddt (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_ddt() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_r: public Ope_eq {
 
    public:
        Ope_div_r (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_r() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_rsint: public Ope_eq {
 
    public:
        Ope_div_rsint (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_rsint() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_mult_rsint: public Ope_eq {
 
    public:
        Ope_mult_rsint (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_mult_rsint() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_cost: public Ope_eq {
 
    public:
        Ope_div_cost (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_cost() override ; 
    
        Term_eq action() const override;
} ;
 
 
 
class Ope_div_xpone: public Ope_eq {
 
    public:
        Ope_div_xpone (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_xpone() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_1mx2: public Ope_eq {
 
    public:
        Ope_div_1mx2 (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_1mx2() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_1mrsL: public Ope_eq {
 
    public:
        Ope_div_1mrsL (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_1mrsL() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_mult_1mrsL: public Ope_eq {
 
    public:
        Ope_mult_1mrsL (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_mult_1mrsL() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_mult_sint: public Ope_eq {
 
    public:
        Ope_mult_sint (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_mult_sint() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_div_sint: public Ope_eq {
 
    public:
        Ope_div_sint (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_div_sint() override ; 
    
        Term_eq action() const override;
} ;
 
 
class Ope_partial : public Ope_eq {
    protected:
        char ind_der ; 
    public:
        Ope_partial (const System_of_eqs* syst, char name, Ope_eq* so) ;
        ~Ope_partial() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_determinant : public Ope_eq {
    public:
        Ope_determinant (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_determinant() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_inverse : public Ope_eq {
    public:
        Ope_inverse (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_inverse() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_inverse_nodet : public Ope_eq {
    public:
        Ope_inverse_nodet (const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_inverse_nodet() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_partial_var : public Ope_eq {
    protected:
      int which_var ;
 
    public:
        Ope_partial_var (const System_of_eqs* syst, int which, Ope_eq* so) ;
        ~Ope_partial_var() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_mode : public Ope_eq {
    protected:     
        int bound ; 
        Index pos_cf ;
        double value ; 
 
    public:
        Ope_mode (const System_of_eqs* syst, int bb, const Index& ind, double val, Ope_eq* so) ;
        ~Ope_mode() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_val_mode : public Ope_eq {
    protected:     
        Index pos_cf ; 
        double value ;
 
    public:
        Ope_val_mode (const System_of_eqs* syst, const Index& ind, double val, Ope_eq* so) ;
        ~Ope_val_mode() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_val : public Ope_eq {
    protected:     
        Index pos ; 
 
    public:
        Ope_val(const System_of_eqs* syst, const Index& ind, Ope_eq* so) ;
        ~Ope_val() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_point : public Ope_eq {
    protected:     
        Point num; 
 
    public:
        Ope_point(const System_of_eqs* syst, const Point& pp, Ope_eq* so) ;
        ~Ope_point() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_val_ori : public Ope_eq {
 
    public:
        Ope_val_ori(const System_of_eqs* syst, int dd, Ope_eq* so) ;
        ~Ope_val_ori() override ; 
 
        Term_eq action() const override;
} ;
 
class Ope_sqrt: public Ope_eq {
 
    public:
        Ope_sqrt(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_sqrt() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_sqrt_anti: public Ope_eq {
 
    public:
        Ope_sqrt_anti(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_sqrt_anti() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_sqrt_nonstd: public Ope_eq {
 
    public:
        Ope_sqrt_nonstd(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_sqrt_nonstd() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_exp: public Ope_eq {
 
    public:
        Ope_exp(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_exp() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_log: public Ope_eq {
 
    public:
        Ope_log(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_log() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_cosh: public Ope_eq {
 
    public:
        Ope_cosh(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_cosh() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_sinh: public Ope_eq {
 
    public:
        Ope_sinh(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_sinh() override ; 
    
        Term_eq action() const override;
} ;
 
 
class Ope_atanh: public Ope_eq {
 
    public:
        Ope_atanh(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_atanh() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_cos: public Ope_eq {
 
    public:
        Ope_cos(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_cos() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_sin: public Ope_eq {
 
    public:
        Ope_sin(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_sin() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_fit_waves : public Ope_eq {
    public:
        Ope_fit_waves (const System_of_eqs* syst, Ope_eq* so, Ope_eq* ome) ;
        ~Ope_fit_waves() override ; 
      
        Term_eq action() const override;
} ;
 
class Ope_user: public Ope_eq {
    protected:
        Param* par ; 
        Term_eq (*pope) (const Term_eq&, Param*) ; 
 
    public:
        Ope_user (const System_of_eqs* syst, Term_eq (*zeope) (const Term_eq&, Param*), Param* par, Ope_eq* so) ;
        ~Ope_user() override ; 
        Term_eq action() const override;
} ;
 
class Ope_user_bin: public Ope_eq {
    protected:
        Param* par ;  
        Term_eq (*pope) (const Term_eq&, const Term_eq&, Param*) ;  
 
    public:
        Ope_user_bin (const System_of_eqs* syst, Term_eq (*zeope) (const Term_eq&, const Term_eq&, Param*), Param* par, Ope_eq* aa, Ope_eq* bb) ;
        ~Ope_user_bin() override ; 
        Term_eq action() const override;
} ;
 
 
class Ope_import: public Ope_eq {
 
    protected:
        int bound ; 
        Array<int> others ; 
 
    public:
        Ope_import(const System_of_eqs* syst, int dd, int bb, const char* field) ;
        ~Ope_import() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_change_basis: public Ope_eq {
 
    protected:
        int target_basis ; 
 
    public:
        Ope_change_basis(const System_of_eqs* syst, int target, Ope_eq* so) ;
        ~Ope_change_basis() override ; 
    
        Term_eq action() const override;
} ;
 
class Ope_def_global : public Ope_eq {
    protected:
        Term_eq* res ; 
        Term_eq** auxi ; 
    public:
        Ope_def_global (const System_of_eqs* syst, int dom, const char* name_ope) ;
        ~Ope_def_global() override ;
        Term_eq action() const override;
        Term_eq* get_res() ;
        void compute_res() ; 
} ;
 
class Ope_conjug: public Ope_eq {
  
    public:
        Ope_conjug(const System_of_eqs* syst, Ope_eq* so) ;
        ~Ope_conjug() override ; 
    
        Term_eq action() const override;
} ;
}
#endif