include/continewz/analytic_sugar.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : analytic_sugar.hpp
* DESCRIPTION: Recursive and implicit analytic functions via routines
* COPYRIGHT  : (C) 2010  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __MMX_ANALYTIC_SUGAR_HPP
#define __MMX_ANALYTIC_SUGAR_HPP
#include <basix/routine.hpp>
#include <algebramix/series_sugar.hpp>
#include <continewz/analytic_vector.hpp>
namespace mmx {
#define TMPL template<typename C>
#define Vector vector<C>
#define Analytic analytic<C>
#define Scalar typename unvectorize<C>::val

/******************************************************************************
* Exported functions
******************************************************************************/

TMPL Analytic
fixed_point_analytic (const routine& fun, const C& c);
TMPL analytic<Vector >
fixed_point_analytic_vector (const routine& fun, const Vector& c);
TMPL vector<Analytic >
fixed_point_vector_analytic (const routine& fun, const Vector& c);
TMPL vector<generic>
gen_fixed_point_vector_analytic (const routine& fun, const Vector& c);

/******************************************************************************
* Fixed point analytic
******************************************************************************/

TMPL
class fixed_point_analytic_rep: public recursive_analytic_rep<C> {
  routine fun;
  C       c;
public:
  fixed_point_analytic_rep (const routine& fun2, const C& c2):
    recursive_analytic_rep<C> (get_format (c2)), fun (fun2), c (c2) {}
  syntactic expression (const syntactic& z) const {
    (void) z;
    return apply ("fixed_point", flatten (fun), flatten (c)); }
  series<C> Expand () const {
    return fixed_point_series (fun, c); }
  C Initial () const {
    return c; }
  Analytic Equation () const {
    return as<Analytic > (fun->apply (as<generic> (this->me ()))); }
  Analytic Move (const Scalar& z) const {
    return fixed_point_analytic (fun, eval (this->me (), z)); }
  Analytic Derive () const {
    ERROR ("not yet implemented"); }
};

TMPL inline Analytic
fixed_point_analytic (const routine& fun, const C& c) {
  return recursive (new fixed_point_analytic_rep<C> (fun, c));
}

TMPL inline Analytic
integrate_analytic (const routine& fun, const C& c) {
  return fixed_point_analytic (integrate (fun), c);
}

TMPL
class fixed_point_vector_analytic_rep:
  public recursive_analytic_rep<Vector >
{
  routine fun;
  Vector  c;
public:
  fixed_point_vector_analytic_rep
    (const routine& fun2, const Vector& c2):
      recursive_analytic_rep<Vector > (get_format (c2)),
      fun (fun2), c (c2) {}
  syntactic expression (const syntactic& z) const {
    (void) z;
    return apply ("fixed_point", flatten (fun), flatten (c)); }
  series<Vector > Expand () const {
    return fixed_point_series_vector (fun, c); }
  Vector Initial () const {
    return c; }
  analytic<Vector > Equation () const {
    vector<Analytic > in= as_vector (this->me ());
    generic genout= fun->apply (as<generic> (as<vector<generic> > (in)));
    vector<Analytic > out=
      as<vector<Analytic > > (as<vector<generic> > (genout));
    return from_vector (out); }
  analytic<Vector > Move (const Scalar& z) const {
    return fixed_point_analytic_vector (fun, eval (this->me (), z)); }
  analytic<Vector > Derive () const {
    ERROR ("not yet implemented"); }
};

TMPL inline analytic<Vector >
fixed_point_analytic_vector (const routine& fun, const Vector& c) {
  return recursive (new fixed_point_vector_analytic_rep<C> (fun, c));
}

TMPL inline vector<Analytic >
fixed_point_vector_analytic (const routine& fun, const Vector& c) {
  return as_vector (fixed_point_analytic_vector (fun, c));
}

TMPL inline vector<generic>
gen_fixed_point_vector_analytic (const routine& fun, const Vector& c) {
  return as<vector<generic> > (fixed_point_vector_analytic (fun, c));
}

TMPL inline vector<generic>
gen_integrate_vector_analytic (const routine& fun, const Vector& c) {
  return gen_fixed_point_vector_analytic (integrate (fun), c);
}

#undef TMPL
#undef Vector
#undef Analytic
#undef Scalar
} // namespace mmx
#endif // __MMX_ANALYTIC_IMPLICIT_HPP

---