implicit_vector_series_rep< C, V > Class Template Reference

#include <series_sugar.hpp>

Inheritance diagram for implicit_vector_series_rep< C, V >:

List of all members.

Public Member Functions

• implicit_vector_series_rep (const routine &fun2, const vector< vector< C > > &c2)
• syntactic expression (const syntactic &z) const
• vector< series< unknown< C, V > > > initialize ()
• virtual void Increase_order (nat l)
• virtual syntactic name_component (nat i)
• vector< series< unknown< C, V > > > me ()
• vector< C > next ()

Public Attributes

• nat m
• vector< series< unknown< C, V > > > eqs
• nat cur_n
• vector< unknown< C, V > > sys

---

Detailed Description

template<typename C, typename V = typename Series_variant(C)>
class mmx::implicit_vector_series_rep< C, V >

Definition at line 157 of file series_sugar.hpp.

---

Constructor & Destructor Documentation

implicit_vector_series_rep	(	const routine &	fun2,
		const vector< vector< C > > &	c2
	)		[inline]

Definition at line 161 of file series_sugar.hpp.

                                                           :
    Solver_rep (N(c2[0]), c2), fun (fun2), c (c2) {}

---

Member Function Documentation

syntactic expression

(

const syntactic &

z

)

const [inline]

Definition at line 164 of file series_sugar.hpp.

References mmx::flatten().

                                                  {
    (void) z;
    return apply ("implicit", flatten (fun), flatten (c)); }

void Increase_order

(

nat

l

)

[virtual, inherited]

Definition at line 435 of file series_implicit.hpp.

References mmx::increase_order(), and mmx::N().

                                 {
  VSeries_rep::Increase_order (l);
  for (nat i=0; i<N(eqs); i++)
    increase_order (eqs[i], l);
}

vector< series< unknown<C,V> > > initialize

(

)

[inline, virtual]

Implements solver_series_rep< C, V >.

Definition at line 167 of file series_sugar.hpp.

References solver_series_rep< C, V >::me().

                                 {
    /*
    vector<USeries> mmm= this->me ();
    for (nat i=0; i<N(mmm); i++)
      for (nat j=0; j<3; j++)
        mmerr << i << ", " << j << " -> " << mmm[i][j] << "\n";
    */
    vector<generic> in =
      as<vector<generic> > (this->me ());
    vector<generic> out=
      as<vector<generic> > (fun->apply (as<generic> (in)));
    /*
    vector<USeries> rrr= as<vector<USeries > > (out);
    for (nat i=0; i<N(rrr); i++)
      for (nat j=0; j<3; j++)
        mmerr << i << ", " << j << " -> " << rrr[i][j] << "\n";    
    */
    return as<vector<USeries > > (out); }

vector< series< unknown< C, V > > > me

(

)

[inherited]

Definition at line 448 of file series_implicit.hpp.

References mmx::unknown_series().

Referenced by implicit_vector_series_rep< C, V >::initialize(), and implicit_series_rep< C, V >::initialize().

                {
  vector<USeries > r= fill<USeries > (m);
  for (nat i=0; i<m; i++)
    r[i]= unknown_series (this, i);
  return r;
}

syntactic name_component

(

nat

i

)

[virtual, inherited]

Definition at line 442 of file series_implicit.hpp.

References mmx::access(), and mmx::flatten().

                                 {
  if (m == 1) return syntactic ("f");
  else return access (syntactic ("f"), flatten (i+1));
}

vector< C > next

(

)

[inherited]

Definition at line 456 of file series_implicit.hpp.

References mmx::C, mmx::insert_and_reduce(), mmx::is_exact_zero(), mmx::N(), Solver_rep, mmx::substitute(), UC, and VC.

                  {
  //mmerr << "Solving " << this->n << "\n";
  for (nat i=0; i<N(sys); i++)
    sys[i]= substitute (sys[i]);
  VC  ret = fill<C> (m);
  nat done= 0;
  while (true) {
    ASSERT (cur_n < this->n + 100, "too large delay in implicit solve");
    //mmerr << "  Coefficient " << cur_n << "\n";
    for (nat j=0; j<N(eqs); j++) {
      UC c= eqs[j][cur_n];
      //mmerr << "    Equation " << j << "= " << c << "\n";
      insert_and_reduce (sys, c);
    }
    //mmerr << "  System= " << sys << "\n";
    cur_n++;
    for (nat i=0; i<N(sys); i++)
      ASSERT (sys[i]->f == ((Solver_rep*) this) &&
              sys[i]->i1 >= this->n * m && sys[i]->i2 > this->n * m,
              "invalid situation during implicit solving");
    while (N(sys) > 0 && done < m) {
      UC c= sys[N(sys)-1];
      if (c->i2 <= this->n * m + done + 1) {
        nat j1 = c->i1 - this->n * m;
        nat j2 = min (done, c->i2 - this->n * m);
        C   rhs= c->b;
        for (nat j=j1; j<j2; j++)
          rhs += c->s[j-j1] * ret[j];
        if (c->i2 <= this->n * m + done) {
          ASSERT (is_exact_zero (rhs), "contradictory equations"); }
        else {
          ret[done]= -rhs / c->s[done-j1];
          //mmerr << "  Component " << done << "= " << ret[done] << "\n";
          done++;
        }
        sys.secure ();
        inside (sys) -> resize (N(sys) - 1);
      }
      else break;
    }
    if (done == m) return ret;
  }
}

---

Member Data Documentation

nat cur_n [inherited]

Definition at line 103 of file series_implicit.hpp.

vector< series< unknown<C,V> > > eqs [inherited]

Definition at line 102 of file series_implicit.hpp.

nat m [inherited]

Definition at line 101 of file series_implicit.hpp.

vector< unknown<C,V> > sys [inherited]

Definition at line 104 of file series_implicit.hpp.

---

The documentation for this class was generated from the following file:

• /Users/mourrain/Devel/mmx/algebramix/include/algebramix/series_sugar.hpp