include/algebramix/series_vector.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : series_vector.hpp
* DESCRIPTION: Vectors and matrices of univariate power series
* COPYRIGHT  : (C) 2011  J. Berthomieu, J. van der Hoeven and R. Lebreton
*******************************************************************************
* 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_SERIES_VECTOR_HPP
#define __MMX_SERIES_VECTOR_HPP
#include <basix/vector.hpp>
#include <algebramix/series.hpp>
#include <algebramix/matrix.hpp>
#include <algebramix/series_matrix.hpp>

namespace mmx {
#define TMPL template<typename C, typename V, typename W>
#define TMPLU template<typename C, typename V, typename U>
#define TMPLWU template<typename C, typename V, typename W, typename U>
#define Series series<C,V>
#define Vector vector<C,W>
#define Matrix matrix<C,U>
#define Series_rep series_rep<C,V>
#define Series_vector series<Vector,V>
#define Vector_series vector<Series,W>
#define Series_matrix series<Matrix,V>
#define Matrix_series matrix<Series,U>
#define Polynomial polynomial<C, typename series_polynomial_helper<C,V>::PV>

/******************************************************************************
* Variants
******************************************************************************/

template<typename C, typename V>
struct series_variant_helper<vector<C,V> > {
  typedef typename series_variant_helper<C>::SV SV;
};

/******************************************************************************
* Vectors of series
******************************************************************************/

STYPE_TO_TYPE(TMPL,as_vector_type,Series_vector,Vector_series);

TMPL
class vector_access_series_rep: public Series_rep {
  const Series_vector f;
  const nat i;
public:
  vector_access_series_rep (const Series_vector& f2, nat i2):
    Series_rep (get_format1 (CF(f2))), f (f2), i (i2) {}
  syntactic expression (const syntactic& z) const {
    return access (flatten (f, z), flatten (i)); }
  void Increase_order (nat l) {
    Series_rep::Increase_order (l);
    increase_order (f, l); }
  C next () {
    if (is_a_scalar (f[this->n])) return C();
    return i < N(f[this->n]) ? f[this->n][i] : C(); }
};

TMPL Series
access (const Series_vector& f, nat i) {
  return (Series_rep*) new vector_access_series_rep<C,V,W> (f, i);
}

TMPL Vector_series
as_vector (const Series_vector& f, nat n) {
  Vector_series v (Series (get_format1 (CF(f))), n);
  for (nat i=0; i<n; i++)
    v[i]= access (f, i);
  return v;
}

TMPL inline Vector_series
as_vector (const Series_vector& f) {
  return as_vector (f, N(f[0]));
}

TMPL syntactic
flatten (const Vector_series& v, const syntactic& z) {
  syntactic g;
  nat i, n= N(v);
  vector<syntactic,W> r (g, n);
  for (i=0; i<n; i++)
    r[i]= flatten (v[i], z);
  return flatten (r);
}

TMPL format<Vector >
get_vector_format (const Vector_series& v) {
  format<Series > fm1= CF(v);
  format<C> fm2= get_format1 (fm1);
  C zero= promote (0, fm2);
  Vector r (zero, N(v));
  return get_format (r);
}

TMPL
class vector_series_rep: public series_rep<Vector,V> {
  const Vector_series v;
public:
  vector_series_rep (const Vector_series& v2):
    series_rep<Vector,V> (get_vector_format (v2)), v (v2) {}
  syntactic expression (const syntactic& z) const {
    return flatten (v, z); }
  void Increase_order (nat l) {
    series_rep<Vector,V>::Increase_order (l);
    for (nat i=0; i<N(v); i++)
      increase_order (v[i], l); }
  Vector next () {
    nat i, n= N(v);
    Vector coeff (promote (0, get_format1 (CF(v))), n);
    for (i=0; i<n; i++)
      coeff[i]= v[i][this->n];
    return coeff; }
};

TMPL Series_vector
as_series (const Vector_series& v) {
  return (series_rep<Vector,V>*) new vector_series_rep<C,V,W> (v);
}

TMPL Series_vector
from_vector (const Vector_series& v) {
  return (series_rep<Vector,V>*) new vector_series_rep<C,V,W> (v);
}

TMPL vector<Polynomial >
range (const Vector_series& v, nat start, nat end) {
  vector<Polynomial > r= fill<Polynomial > (N(v));
  for (nat i=0; i<N(v); i++)
    r[i]= range (v[i], start, end);
  return r;
}

TMPL
class lshiftz_series_vector_rep: public series_rep<Vector,V> {
  Series_vector f;
  nat s;
  int shift;
public:
  lshiftz_series_vector_rep (const Series_vector& f2, nat s2, int shift2):
    series_rep<Vector,V> (CF(f2)),
    f (f2), s (s2), shift (shift2) {}
  syntactic expression (const syntactic& z) const {
    return lshiftz (flatten (f, z), flatten (shift)); }
  void Increase_order (nat l) {
    series_rep<Vector,V>::Increase_order (l);
    increase_order (f, max (0, ((int) l) - shift)); }
  Vector next () { return shift > ((int) this->n)? 
      Vector (promote (0, get_format1 (CF(f))), s):
      f[this->n - shift]; }
};

TMPL inline Series_vector
lshiftz_series_vector (const Series_vector& f, const nat& n,
                       const int& shift=1) {
  if (is_exact_zero (f)) {
    Series zero (get_format1 (CF(f)));
    return as_series (Vector_series (zero, n));
  }
  return (series_rep<Vector,V>*) 
    new lshiftz_series_vector_rep<C,V,W> (f, n, shift);
}

/******************************************************************************
* Linear differential equations
******************************************************************************/

TMPL Series_vector
solve_vector_lde_init (const Series_vector& f, const Vector& c) {
  return unary_recursive_series<solve_vector_lde_op> (f, c);
}

TMPL Vector_series
solve_lde_init (const Vector_series& f, const Vector& c) {
  return as_vector (solve_vector_lde_init (as_series (f), c));
}

TMPL Series // FIXME: obsolete
solve_lde (const Vector_series& f, const Vector& c) {
  return read (solve_lde_init (f, c), 0);
}

#undef Polynomial
#undef Series_matrix
#undef Matrix_series
#undef Vector_series
#undef Series_vector
#undef Vector
#undef Matrix
#undef Series
#undef Series_rep
#undef TMPLWU
#undef TMPLU
#undef TMPL
} // namespace mmx
#endif // __MMX_SERIES_VECTOR_HPP

---