/Users/mourrain/Devel/mmx/algebramix/include/algebramix/quotient_series.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : quotient_series.hpp
* DESCRIPTION: Laurent series (both univariate and multivariate)
* COPYRIGHT  : (C) 2007  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__QUOTIENT_SERIES__HPP
#define __MMX__QUOTIENT_SERIES__HPP
#include <algebramix/series.hpp>

namespace mmx {
#define TMPL_DEF template<typename Series, typename Monomial>
#define TMPL template<typename Series, typename Monomial>
#define C typename scalar_type_helper<Series>::val
#define Stair list<Monomial >
#define Variable typename Series::variable_type
#define Quotient_series quotient_series<Series,Monomial>
#define Quotient_series_rep quotient_series_rep<Series,Monomial>
#define Set table<bool,Variable >
TMPL class quotient_series_rep;
TMPL class quotient_series;

/******************************************************************************
* Quotient_series
******************************************************************************/

TMPL_DEF
class quotient_series_rep REP_STRUCT {
public:
  Series   f;
  Monomial m;
  inline quotient_series_rep ():
    f (0), m (1) {}
  inline quotient_series_rep (const Series& f2):
    f (f2), m (1) {}
  inline quotient_series_rep (const Series& f2, const Monomial& m2):
    f (f2), m (m2) {}
  inline quotient_series_rep (const Monomial& m2):
    f (1), m (m2) {}
  inline ~quotient_series_rep () {}
};

TMPL_DEF
class quotient_series {
INDIRECT_PROTO_2 (quotient_series, quotient_series_rep, Series, Monomial)
public:
  inline quotient_series ():
    rep (new Quotient_series_rep ()) {}
  template<typename T> inline quotient_series (const T& c):
    rep (new Quotient_series_rep (Series (c))) {}
  inline quotient_series (const Monomial& m):
    rep (new Quotient_series_rep (m)) {}
  inline quotient_series (const Series& f, const Monomial& m):
    rep (new Quotient_series_rep (f, m)) {}
  inline C operator [] (const Monomial& m) const {
    return rep->f [m / rep->m]; }

  static inline generic get_variable_name () {
    return Series::get_variable_name (); }
  static inline void set_variable_name (const generic& x) {
    Series::set_variable_name (x); }

  static inline nat get_output_order () {
    return Series::get_output_order (); }
  static inline void set_output_order (const nat& x) {
    Series::set_output_order (x); }

  static inline nat get_cancel_order () {
    return Series::get_cancel_order (); }
  static inline void set_cancel_order (const nat& x) {
    Series::set_cancel_order (x); }

  static inline bool get_formula_output () {
    return Series::get_formula_output (); }
  static inline void set_formula_output (const bool& x) {
    Series::set_formula_output (x); }
};
INDIRECT_IMPL_2 (quotient_series, quotient_series_rep,
                 typename Series, Series, typename Monomial, Monomial)

STYPE_TO_TYPE(TMPL,scalar_type,Quotient_series);

TMPL inline nat hash (const Quotient_series& f) {
  // FIXME: find something better to return here
  (void) f; return 0; }
TMPL inline bool
operator == (const Quotient_series& f, const Quotient_series& g) {
  Monomial m= gcd (f->m, g->m);
  return f->f * (g->m / m) == g->f * (f->m / m); }
TMPL inline bool
operator != (const Quotient_series& f, const Quotient_series& g) {
  return !(f == g); }
TMPL inline nat exact_hash (const Quotient_series& f) {
  return exact_hash (f->f) ^ exact_hash (f->m); }
TMPL inline bool
exact_eq (const Quotient_series& f, const Quotient_series& g) {
  return exact_eq (f->f, g->f) && exact_eq (f->m, g->m); }
TMPL inline bool
exact_neq (const Quotient_series& f, const Quotient_series& g) {
  return !exact_eq (f, g); }

TMPL inline syntactic flatten (const Quotient_series& f) {
  return flatten (f->f) * flatten (f->m); }

/******************************************************************************
* Support related routines
******************************************************************************/

TMPL inline Set variables (const Quotient_series& f) {
  return variables (f->f) | variables (f->m); }
TMPL inline int val (const Quotient_series& f, const Variable& v) {
  return val (f->f, v) * f->m[v]; }
TMPL inline Monomial monomial_val (const Quotient_series f) {
  return monomial_val (f->f) * f->m; }

TMPL Quotient_series project (const Quotient_series& f, const Stair& l) {
  return Quotient_series (project (f->f, stair_mul (1/f->m, l)), f->m); }
TMPL Quotient_series head (const Quotient_series& f, const Stair& l) {
  return Quotient_series (head (f->f, stair_mul (1/f->m, l)), f->m); }
TMPL Quotient_series tail (const Quotient_series& f, const Stair& l) {
  return Quotient_series (tail (f->f, stair_mul (1/f->m, l)), f->m); }
TMPL Stair dominant_monomials (const Quotient_series& f) {
  return stair_mul (f->m, dominant_monomials (f->f)); }
TMPL inline Quotient_series
normalize (const Quotient_series& f, const Monomial& dom_m) {
  return Quotient_series (lshiftz (f->f, f->m / dom_m), dom_m); }

/******************************************************************************
* Basic arithmetic
******************************************************************************/

TMPL Quotient_series
operator + (const Quotient_series& f, const Quotient_series& g) {
  if (f->m == g->m) return Quotient_series (f->f + g->f, f->m);
  else {
    Monomial m= gcd (f->m, g->m);
    return Quotient_series (f->f * (f->m / m) + g->f * (g->m / m), m);
  }
}

TMPL Quotient_series
operator + (const Quotient_series& f, const C& c) {
  return Quotient_series (f->f + Quotient_series (c));
}

TMPL Quotient_series
operator + (const C& c, const Quotient_series& f) {
  return Quotient_series (Quotient_series (c) + f->f);
}

TMPL Quotient_series
operator - (const Quotient_series& f) {
  return Quotient_series (-f->f, f->m);
}

TMPL Quotient_series
operator - (const Quotient_series& f, const Quotient_series& g) {
  if (f->m == g->m) return Quotient_series (f->f - g->f, f->m);
  else {
    Monomial m= gcd (f->m, g->m);
    return Quotient_series (f->f * (f->m / m) - g->f * (g->m / m), m);
  }
}

TMPL Quotient_series
operator - (const Quotient_series& f, const C& c) {
  return Quotient_series (f->f - Quotient_series (c));
}

TMPL Quotient_series
operator - (const C& c, const Quotient_series& f) {
  return Quotient_series (Quotient_series (c) - f->f);
}

TMPL Quotient_series
operator * (const Monomial& m, const Quotient_series& f) {
  return Quotient_series (f->f, m * f->m);
}

TMPL Quotient_series
operator * (const Quotient_series& f, const Monomial& m) {
  return Quotient_series (f->f, f->m * m);
}

TMPL Quotient_series
operator * (const C& c, const Quotient_series& f) {
  return Quotient_series (c * f->f, f->m);
}

TMPL Quotient_series
operator * (const Quotient_series& f, const C& c) {
  return Quotient_series (c * f->f, f->m);
}

TMPL Quotient_series
operator * (const Quotient_series& f, const Quotient_series& g) {
  return Quotient_series (f->f * g->f, f->m * g->m);
}

TMPL Quotient_series
operator / (const Quotient_series& f, const Monomial& m) {
  return Quotient_series (f->f, f->m / m);
}

TMPL Quotient_series
operator / (const Monomial& m, const Quotient_series& f) {
  Monomial v= monomial_val (f);
  if (v != Monomial (1)) return (m/v) / (f/v);
  return Quotient_series (C(1) / f->f, m / f->m);
}

TMPL Quotient_series
operator / (const Quotient_series& f, const C& c) {
  return Quotient_series (f->f / c, f->m);
}

TMPL Quotient_series
operator / (const C& c, const Quotient_series& f) {
  Monomial v= monomial_val (f);
  if (v != Monomial (1)) return (c / (f/v)) / v;
  return Quotient_series (c / f->f, Monomial (1) / f->m);
}

TMPL Quotient_series
operator / (const Quotient_series& f, const Quotient_series& g) {
  Monomial v= monomial_val (g);
  if (v != Monomial (1)) return (f/v) / (g/v);
  return Quotient_series (f->f / g->f, f->m);
}

ARITH_SCALAR_INT_SUGAR(TMPL,Quotient_series);

#undef TMPL_DEF
#undef TMPL
#undef C
#undef Stair
#undef Variable
#undef Quotient_series
#undef Quotient_series_rep
#undef Set
} // namespace mmx
#endif // __MMX__QUOTIENT_SERIES__HPP