Move ranked function from MonoitTrait to MonoidFamily

ext/garside/braids.hpp

@@ -51,6 +51,9 @@ size_t ArtinA_gnum(size_t n);
 //! Set left complement for Artin monoid of type A
 int ArtinA_left_sc(const Generator& x,const Generator &y,Generator* comp);
 
+//! Return the rank of an Artin generator of type A
+size_t ArtinA_rank(const Generator& x);
+
 //! Set right complement for Artin monoid of type A
 int ArtinA_right_sc(const Generator& x,const Generator &y,Generator* comp);
 
@@ -76,6 +79,9 @@ size_t DualA_gnum(size_t n);
 //! Set left complement for dual monoid of type A
 int DualA_left_sc(const Generator& x,const Generator &y,Generator* comp);
 
+//! Return the rank of an dual generator of type A
+size_t DualA_rank(const Generator& x);
+
 //! Set right complement for dual monoid of type A
 int DualA_right_sc(const Generator& x,const Generator &y,Generator* comp);
 
@@ -108,6 +114,11 @@ ArtinA_gnum(size_t n){
   return n-1;
 }
 
+inline size_t
+ArtinA_rank(const Generator& x){
+  return abs(x);
+}
+
 inline string
 DualA_disp(const Generator& x){
   if(x==0) return "e";
@@ -115,6 +126,11 @@ DualA_disp(const Generator& x){
   return "A"+to_string(get_i(-x))+to_string(get_j(-x));
 }
 
+inline size_t
+DualA_rank(const Generator& x){
+  return get_j(abs(x))-1;
+}
+
 inline Generator
 generator(uint8_t i,uint8_t j){
   Generator res=j;

ext/garside/init.cpp

@@ -90,7 +90,7 @@ extern "C"{
   
   Gomu::Module::Function member_functions[]={
     //ArtinMonoidFamilyA
-    {"ArtinWordA","garside_element",{"ArtinMonoidFamilyA","Integer"},(void*)mt_garside_element},
+    {"ArtinWordA","garside_element",{"ArtinMonoidFamilyA","Integer"},(void*)mf_garside_element},
     {"Boolean","is_left_divisible",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_is_left_divisible},
     {"Tuple","is_left_divisible_x",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_is_left_divisible_x},
     {"Boolean","is_right_divisible",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_is_right_divisible},
@@ -104,11 +104,11 @@ extern "C"{
     {"ArtinWordA","left_numerator",{"ArtinMonoidFamilyA"},(void*)mt_left_numerator},
     {"ArtinWordA","left_reverse",{"ArtinMonoidFamilyA","ArtinWordA"},(void*)mt_left_reverse},
     {"ArtinWordA","left_reverse",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_left_reverse2},
-    {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi},
-    {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA","Integer"},(void*)mt_phi_power},
-    {"ArtinWordA","phi_tail",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi_tail},
-    {"Tuple","phi_tail_x",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi_tail_x},
-    {"Array","phi_splitting",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mt_phi_splitting},
+    {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi},
+    {"ArtinWordA","phi",{"ArtinMonoidFamilyA","Integer","ArtinWordA","Integer"},(void*)mf_phi_power},
+    {"ArtinWordA","phi_tail",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_tail},
+    {"Tuple","phi_tail_x",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_tail_x},
+    {"Array","phi_splitting",{"ArtinMonoidFamilyA","Integer","ArtinWordA"},(void*)mf_phi_splitting},
     {"ArtinWordA","right_complement",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_right_complement},
     {"ArtinWordA","right_denominator",{"ArtinMonoidFamilyA"},(void*)mt_right_denominator},
     {"ArtinWordA","right_lcm",{"ArtinMonoidFamilyA","ArtinWordA","ArtinWordA"},(void*)mt_right_lcm},
@@ -124,7 +124,7 @@ extern "C"{
     {"ArtinWordA","inverse",{"ArtinWordA"},(void*)word_inverse},
 
     //DualMonoidFamilyA
-    {"DualWordA","garside_element",{"DualMonoidFamilyA","Integer"},(void*)mt_garside_element},
+    {"DualWordA","garside_element",{"DualMonoidFamilyA","Integer"},(void*)mf_garside_element},
     {"Boolean","is_left_divisible",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_is_left_divisible},
     {"Tuple","is_left_divisible_x",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_is_left_divisible_x},
     {"Boolean","is_right_divisible",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_is_right_divisible},
@@ -138,11 +138,11 @@ extern "C"{
     {"DualWordA","left_numerator",{"DualMonoidFamilyA"},(void*)mt_left_numerator},
     {"DualWordA","left_reverse",{"DualMonoidFamilyA","DualWordA"},(void*)mt_left_reverse},
     {"DualWordA","left_reverse",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_left_reverse2},
-    {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi},
-    {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA","Integer"},(void*)mt_phi_power},
-    {"DualWordA","phi_tail",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi_tail},
-    {"Tuple","phi_tail_x",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi_tail_x},
-    {"Array","phi_splitting",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mt_phi_splitting},
+    {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi},
+    {"DualWordA","phi",{"DualMonoidFamilyA","Integer","DualWordA","Integer"},(void*)mf_phi_power},
+    {"DualWordA","phi_tail",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_tail},
+    {"Tuple","phi_tail_x",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_tail_x},
+    {"Array","phi_splitting",{"DualMonoidFamilyA","Integer","DualWordA"},(void*)mf_phi_splitting},
     {"DualWordA","right_complement",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_right_complement},
     {"DualWordA","right_denominator",{"DualMonoidFamilyA"},(void*)mt_right_denominator},
     {"DualWordA","right_lcm",{"DualMonoidFamilyA","DualWordA","DualWordA"},(void*)mt_right_lcm},
@@ -207,17 +207,87 @@ extern "C"{
 //* Fonctions definitions *
 //*************************
 
-//-------------------------------------------
-// Word garside_element(MonoidTrait,Integer)
-//-------------------------------------------
+//--------------------------------------------
+// Word garside_element(MonoidFamily,Integer)
+//--------------------------------------------
 
-void* mt_garside_element(void* m,void* r){
-  MonoidTrait* monoid=(MonoidTrait*)m;
+void* mf_garside_element(void* m,void* r){
+  MonoidFamily* monoid=(MonoidFamily*)m;
   if(not monoid->has_garside_element())
     RuntimeError("Monoid doesn't have Garside element");
  return (void*)(new Word(monoid->garside_element(Gomu::get_slong(r))));
 }
 
+//-------------------------------------
+// Word phi(MonoidFamily,Integer,Word)
+//-------------------------------------
+
+void* mf_phi(void* m,void* r,void* w){
+  MonoidFamily* monoid=(MonoidFamily*)m;
+  if(not monoid->has_garside_automorphism())
+    RuntimeError("Monoid has not Garside automorphism");
+  size_t rank=Gomu::get_slong(r);
+  return new Word(monoid->phi(rank,*(Word*)w));
+}
+
+//---------------------------------------------
+// Word phi(MonoidFamily,Integer,Word,Integer)
+//---------------------------------------------
+
+void* mf_phi_power(void* m,void* r,void* w,void* p){
+  MonoidFamily* monoid=(MonoidFamily*)m;
+  if(not monoid->has_garside_automorphism())
+    RuntimeError("Monoid has not Garside automorphism");
+  size_t rank=Gomu::get_slong(r);
+  int power=Gomu::get_slong(p);
+  return new Word(monoid->phi(rank,*(Word*)w,power));
+}
+
+//------------------------------------------
+// Word phi_tail(MonoidFamily,Integer,Word)
+//------------------------------------------
+
+void* mf_phi_tail(void* m,void* r,void* w){
+  MonoidFamily* monoid=(MonoidFamily*)m;
+  if(not monoid->has_garside_automorphism())
+    RuntimeError("Monoid has not Garside automorphism");
+  size_t rank=Gomu::get_slong(r);
+  return new Word(monoid->phi_tail(rank,*(Word*)w));
+}
+
+//---------------------------------------------------
+// (Word,Word) phi_tail_x(MonoidFamily,Integer,Word)
+//---------------------------------------------------
+
+void* mf_phi_tail_x(void* m,void* r,void* w){
+  MonoidFamily* monoid=(MonoidFamily*)m;
+  if(not monoid->has_garside_automorphism())
+    RuntimeError("Monoid has not Garside automorphism");
+  size_t rank=Gomu::get_slong(r);
+  pair<Word,Word> p=monoid->phi_tail_x(rank,*(Word*)w);
+  Gomu::TupleValue* res=new Gomu::TupleValue(2);
+  Gomu::Type* type=(Gomu::Type*)monoid->data;
+  res->tab[0]=Gomu::Value(type,new Word(p.first));
+  res->tab[1]=Gomu::Value(type,new Word(p.second));
+  return (void*)res;
+}
+
+//------------------------------------------------------
+// Array[Word] phi_splitting(MonoidFamily,Integer,Word)
+//------------------------------------------------------
+
+void* mf_phi_splitting(void* m,void* r,void* w){
+  MonoidFamily* monoid=(MonoidFamily*)m;
+  size_t rank=Gomu::get_slong(r);
+  Array<Word> a=monoid->phi_splitting(rank,*(Word*)w);
+  Gomu::ArrayValue* res=new Gomu::ArrayValue(a.size());
+  res->type=(Gomu::Type*)monoid->data;
+  for(size_t i=0;i<res->size;++i){
+    res->tab[i]=(void*)(new Word(a.read(i)));
+  }
+  return (void*)res;
+}
+
 //--------------------------------------------------
 // Boolean is_left_divisible(MonoidTrait,Word,Word)
 //--------------------------------------------------
@@ -359,77 +429,6 @@ void* mt_left_reverse2(void* m,void* num,void* den){
   return (void*)new Word(monoid->left_reverse(*(Word*)num,*(Word*)den));
 }
 
-
-//------------------------------------
-// Word phi(MonoidTrait,Integer,Word)
-//------------------------------------
-
-void* mt_phi(void* m,void* r,void* w){
-  MonoidTrait* monoid=(MonoidTrait*)m;
-  if(not monoid->has_garside_automorphism())
-    RuntimeError("Monoid has not Garside automorphism");
-  size_t rank=Gomu::get_slong(r);
-  return new Word(monoid->phi(rank,*(Word*)w));
-}
-
-//--------------------------------------------
-// Word phi(MonoidTrait,Integer,Word,Integer)
-//--------------------------------------------
-
-void* mt_phi_power(void* m,void* r,void* w,void* p){
-  MonoidTrait* monoid=(MonoidTrait*)m;
-  if(not monoid->has_garside_automorphism())
-    RuntimeError("Monoid has not Garside automorphism");
-  size_t rank=Gomu::get_slong(r);
-  int power=Gomu::get_slong(p);
-  return new Word(monoid->phi(rank,*(Word*)w,power));
-}
-
-//----------------------------------------
-// Word phi_tail(MonoidTrai,Integer,Word)
-//----------------------------------------
-
-void* mt_phi_tail(void* m,void* r,void* w){
-  MonoidTrait* monoid=(MonoidTrait*)m;
-  if(not monoid->has_garside_automorphism())
-    RuntimeError("Monoid has not Garside automorphism");
-  size_t rank=Gomu::get_slong(r);
-  return new Word(monoid->phi_tail(rank,*(Word*)w));
-}
-
-//--------------------------------------------------
-// (Word,Word) phi_tail_x(MonoidTrait,Integer,Word)
-//--------------------------------------------------
-
-void* mt_phi_tail_x(void* m,void* r,void* w){
-  MonoidTrait* monoid=(MonoidTrait*)m;
-  if(not monoid->has_garside_automorphism())
-    RuntimeError("Monoid has not Garside automorphism");
-  size_t rank=Gomu::get_slong(r);
-  pair<Word,Word> p=monoid->phi_tail_x(rank,*(Word*)w);
-  Gomu::TupleValue* res=new Gomu::TupleValue(2);
-  Gomu::Type* type=(Gomu::Type*)monoid->data;
-  res->tab[0]=Gomu::Value(type,new Word(p.first));
-  res->tab[1]=Gomu::Value(type,new Word(p.second));
-  return (void*)res;
-}
-
-//-----------------------------------------------------
-// Array[Word] phi_splitting(MonoidTrait,Integer,Word)
-//-----------------------------------------------------
-
-void* mt_phi_splitting(void* m,void* r,void* w){
-  MonoidTrait* monoid=(MonoidTrait*)m;
-  size_t rank=Gomu::get_slong(r);
-  Array<Word> a=monoid->phi_splitting(rank,*(Word*)w);
-  Gomu::ArrayValue* res=new Gomu::ArrayValue(a.size());
-  res->type=(Gomu::Type*)monoid->data;
-  for(size_t i=0;i<res->size;++i){
-    res->tab[i]=(void*)(new Word(a.read(i)));
-  }
-  return (void*)res;
-}
-
 //----------------------------------------------
 // Word right_complement(MonoidTrait,Word,Word)
 //----------------------------------------------

ext/garside/init.hpp

@@ -39,16 +39,31 @@ string mf_display(void* m);
 //! Delete a MonoidFamily
 void mf_delete(void* m);
 
+//! Return garside element of a given rank
+void* mf_garside_element(void* m,void* r);
+
 //! Return generators number fror rank n
 void* mf_generators_number(void* m,void* n);
 
+//! Return the word under ranked Garside automorphism
+void* mf_phi(void* m,void* r,void* w);
+
+//! Return the word under power of ranked Garside automorphism
+void* mf_phi_power(void* m,void* r,void* w,void* p);
+
+//! Return ranked phi-tail of an element
+void* mf_phi_tail(void* m,void* r,void* w);
+
+//! Return ranked phi-tail of an element together with remainder
+void* mf_phi_tail_x(void* m,void* r,void* w);
+
+//! Return the ranked phi-splitting of an element
+void* mf_phi_splitting(void* m,void* r,void* w);
+
 //***************
 //* MonoidTrait *
 //***************
 
-//! Return garside element of a given rank
-void* mt_garside_element(void* m,void* r);
-
 //! Test is a left divides b
 void* mt_is_left_divisible(void* m,void* a,void* b);
 
@@ -82,21 +97,6 @@ void* mt_left_lcm_complement(void* m,void* a,void* b);
 //! Return left numerator
 void* mt_left_numerator(void* m);
 
-//! Return the word under ranked Garside automorphism
-void* mt_phi(void* m,void* r,void* w);
-
-//! Return the word under power of ranked Garside automorphism
-void* mt_phi_power(void* m,void* r,void* w,void* p);
-
-//! Return ranked phi-tail of an element
-void* mt_phi_tail(void* m,void* r,void* w);
-
-//! Return ranked phi-tail of an element together with remainder
-void* mt_phi_tail_x(void* m,void* r,void* w);
-
-//! Return the ranked phi-splitting of an element
-void* mt_phi_splitting(void* m,void* r,void* w);
-
 //! Left reverse a word
 void* mt_left_reverse(void* m,void* w);
 

ext/garside/monoid.cpp

@@ -317,9 +317,98 @@ RightReversing::set_word(const Word& den,const Word& num){
 //* MonoidFamily *
 //****************
 
-MonoidFamily::~MonoidFamily(){
+//----------------------------------------------------------------------
+// MonoidFamily::MonoidFamily(string,DisplayGenerator,GeneratorsNumber)
+//----------------------------------------------------------------------
+
+MonoidFamily::MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n):label(l),gdisp(d),gnum(n){
+  left_reversing=nullptr;
+  right_reversing=nullptr;
+  ranked_phi_germ=nullptr;
+  ranked_garside_word_factory=nullptr;
+}
+
+//------------------------------------------
+// MonoidFamily::apply_phi(size_t,Word,int)
+//------------------------------------------
+
+void
+MonoidFamily::apply_phi(size_t r,Word& w,int p){
+  size_t s=w.size();
+  for(size_t i=0;i<s;++i){
+    w[i]=ranked_phi_germ(r,w[i],p);
+  }
+}
+
+//------------------------------------
+// MonoidFamily::phi(size_t,Word,int)
+//------------------------------------
+
+Word
+MonoidFamily::phi(size_t r,const Word& w,int p){
+  size_t s=w.size();
+  Word res(s);
+  for(size_t i=0;i<s;++i){
+    res[i]=ranked_phi_germ(r,w[i],p);
+  }
+  return res;
+}
+
+//-------------------------------------
+// MonoidFamily::phi_tail(size_t,Word)
+//-------------*-----------------------
+
+Word
+MonoidFamily::phi_tail(size_t r,const Word& w){
+  Word u=w;
+  Word res;
+  Word delta=garside_element(r);
+  while(true){
+    pair<Word,Word> temp=right_gcd_x(u,delta);
+    if(temp.first.is_empty()) return res;
+    res=res*temp.first;
+    u=temp.second;
+  }
+  return res;
+}
+
+//---------------------------------------
+// MonoidFamily::phi_tail_x(size_t,Word)
+//---------------------------------------
+
+pair<Word,Word>
+MonoidFamily::phi_tail_x(size_t r,const Word& w){
+  Word u=w;
+  Word res;
+  Word delta=garside_element(r);
+  while(true){
+    pair<Word,Word> temp=right_gcd_x(u,delta);
+    if(temp.first.is_empty()) return pair<Word,Word>(u,res);
+    res=res*temp.first;
+    u=temp.second;
+  }
+  return pair<Word,Word>(u,res);
+}
+
+//------------------------------------------
+// MonoidFamily::phi_splitting(size_t,Word)
+//------------------------------------------
+
+Array<Word>
+MonoidFamily::phi_splitting(size_t r,const Word& w){
+  deque<Word> res;
+  Word u=w;
+  while(not u.is_empty()){
+    pair<Word,Word> p=phi_tail_x(r,u);
+    u=phi(r+1,p.first,-1);
+    res.push_front(p.second);
+  }
+  Array<Word> res_array(res.size());
+  for(size_t i=0;i<res.size();++i) res_array[i]=res[i];
+  return res_array;
 }
 
+
 //***************
 //* MonoidTrait *
 //***************
@@ -331,8 +420,6 @@ MonoidFamily::~MonoidFamily(){
 MonoidTrait::MonoidTrait(){
   left_reversing=nullptr;
   right_reversing=nullptr;
-  ranked_phi_germ=nullptr;
-  ranked_garside_word_factory=nullptr;
 }
 //-----------------------------
 // MonoidTrait::~MonoidTrait()
@@ -354,18 +441,6 @@ MonoidTrait::are_equivalent(const Word& u,const Word& v){
   return left_reversing->word.is_empty();
 }
 
-//-----------------------------------------
-// MonoidTrait::apply_phi(size_t,Word,int)
-//------------------------------------------
-
-void
-MonoidTrait::apply_phi(size_t r,Word& w,int p){
-  size_t s=w.size();
-  for(size_t i=0;i<s;++i){
-    w[i]=ranked_phi_germ(r,w[i],p);
-  }
-}
-
 //-----------------------------------------------------------
 // MonoidTrait::is_left_divisible_x(const Word&,const Word&)
 //-----------------------------------------------------------
@@ -428,74 +503,6 @@ MonoidTrait::left_gcd_x(const Word& a,const Word& b){
   return pair<Word,Word>(left_numerator(),div);
 }
 
-//-----------------------------------
-// MonoidTrait::phi(size_t,Word,int)
-//-----------------------------------
-
-Word
-MonoidTrait::phi(size_t r,const Word& w,int p){
-  size_t s=w.size();
-  Word res(s);
-  for(size_t i=0;i<s;++i){
-    res[i]=ranked_phi_germ(r,w[i],p);
-  }
-  return res;
-}
-
-//------------------------------------
-// MonoidTrait::phi_tail(size_t,Word)
-//------------------------------------
-
-Word
-MonoidTrait::phi_tail(size_t r,const Word& w){
-  Word u=w;
-  Word res;
-  Word delta=garside_element(r);
-  while(true){
-    pair<Word,Word> temp=right_gcd_x(u,delta);
-    if(temp.first.is_empty()) return res;
-    res=res*temp.first;
-    u=temp.second;
-  }
-  return res;
-}
-
-//--------------------------------------
-// MonoidTrait::phi_tail_x(size_t,Word)
-//--------------------------------------
-
-pair<Word,Word>
-MonoidTrait::phi_tail_x(size_t r,const Word& w){
-  Word u=w;
-  Word res;
-  Word delta=garside_element(r);
-  while(true){
-    pair<Word,Word> temp=right_gcd_x(u,delta);
-    if(temp.first.is_empty()) return pair<Word,Word>(u,res);
-    res=res*temp.first;
-    u=temp.second;
-  }
-  return pair<Word,Word>(u,res);
-}
-
-//-----------------------------------------
-// MonoidTrait::phi_splitting(size_t,Word)
-//-----------------------------------------
-
-Array<Word>
-MonoidTrait::phi_splitting(size_t r,const Word& w){
-  deque<Word> res;
-  Word u=w;
-  while(not u.is_empty()){
-    pair<Word,Word> p=phi_tail_x(r,u);
-    u=phi(r+1,p.first,-1);
-    res.push_front(p.second);
-  }
-  Array<Word> res_array(res.size());
-  for(size_t i=0;i<res.size();++i) res_array[i]=res[i];
-  return res_array;
-}
-
 //----------------------------------------------------
 // MonoidTrait::right_complement(Generator,Generator)
 //----------------------------------------------------

ext/garside/monoid.hpp

@@ -48,6 +48,8 @@ typedef int(*SetComplement)(const Generator& x,const Generator& y,Generator* com
 typedef string(*DisplayGenerator)(const Generator& x);
 //! Return the number of generators of the monoid of rank n among a monoid familly
 typedef size_t(*GeneratorsNumber)(size_t n);
+//! Return the rank of a Generator
+typedef size_t(*RankGenerator)(const Generator& x);
 //! Ranked Generator bijection
 typedef Generator(*RankedGeneratorBijection)(size_t r,const Generator& x,int p);
 //! Return a ranked word
@@ -167,11 +169,6 @@ public:
   LeftReversing* left_reversing;
   //! Pointer to a RightReversing
   RightReversing* right_reversing;
-  //! Ranked Garside automorphism germ
-  RankedGeneratorBijection ranked_phi_germ;
-  //! Ranked Garside element factory
-  RankedWordFactory ranked_garside_word_factory;
-  
   //! Extra data
   void* data;
   //! Empty constructor
@@ -180,26 +177,14 @@ public:
   //! Destructor
   ~MonoidTrait();
 
-  //! Apply phi_r^p to the word
-  void apply_phi(size_t r,Word& w,int p=1);
-
   //! Test if two words are equivalent
   bool are_equivalent(const Word& u,const Word& v);
-  
-  //! Return garside_element of rank r
-  Word garside_element(size_t r);
-  
+
   //! Test if the family has a left complement
   bool has_left_complement() const;
    
   //! Test if the family has a right complement
   bool has_right_complement() const;
-
-  //! Test if the family has a Garside automorphism
-  bool has_garside_automorphism() const;
-
-  //! Test if the family has a Garside element
-  bool has_garside_element() const;
   
   //! Test if a is left divisible by b, i.e.,if it exists c such that a=b.c */
   bool is_left_divisible(const Word& a,const Word& b);
@@ -245,18 +230,6 @@ public:
   //! Left reverse the u.v^(-1)
   Word left_reverse(const Word& u,const Word& v);
 
-  //! Return the word obtained under phi_r^p
-  Word phi(size_t r,const Word& w,int p=1);
-
-  //! Return ranked phi-tail of an element
-  Word phi_tail(size_t r,const Word& w);
-
-  //! Return ranked phi-tail of an element together with remainder
-  pair<Word,Word> phi_tail_x(size_t r,const Word& w);
-
-  //! Return the ranked phi-splitting of an element
-  Array<Word> phi_splitting(size_t r,const Word& w);
-  
   //! Return right complement of x and y
   Word right_complement(const Generator& x,const Generator& y);
   
@@ -291,14 +264,7 @@ public:
   void set_left_complement(SetComplement sc);
 
   //! Set right complement
-  void set_right_complement(SetComplement sc);
-
-  //! Set ranked phi germ
-  void set_ranked_phi_germ(RankedGeneratorBijection rpg);
-  
-  //! Set ranked garside word factory
-  void set_ranked_garside_word_factory(RankedWordFactory rgwf);
-  
+  void set_right_complement(SetComplement sc); 
 };
 
 //--------------
@@ -314,6 +280,10 @@ public:
   GeneratorsNumber gnum;
   //! Label of the monoid family
   string label;
+  //! Ranked Garside automorphism germ
+  RankedGeneratorBijection ranked_phi_germ;
+  //! Ranked Garside element factory
+  RankedWordFactory ranked_garside_word_factory;
   
   //! Unique constructor
   MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n);
@@ -321,11 +291,46 @@ public:
   //! Destructor
   ~MonoidFamily();
 
+  //! Apply phi_r^p to the word
+  void apply_phi(size_t r,Word& w,int p=1);
+  
   //! Display
   string display() const;
+    
+  //! Return garside_element of rank r
+  Word garside_element(size_t r);
   
   //! Return number of generators for rank n
   size_t generators_number(size_t n);
+
+  //! Test if the family has a Garside automorphism
+  bool has_garside_automorphism() const;
+
+  //! Test if the family has a Garside element
+  bool has_garside_element() const;
+  
+  //! Return the word obtained under phi_r^p
+  Word phi(size_t r,const Word& w,int p=1);
+  
+  //! Return ranked phi-tail of an element
+  Word phi_tail(size_t r,const Word& w);
+
+  //! Return ranked phi-tail of an element together with remainder
+  pair<Word,Word> phi_tail_x(size_t r,const Word& w);
+
+  //! Return the ranked phi-splitting of an element
+  Array<Word> phi_splitting(size_t r,const Word& w);
+
+  //! Return rank of a Word
+  size_t rank(const Word& w);
+
+    //! Set ranked phi germ
+  void set_ranked_phi_germ(RankedGeneratorBijection rpg);
+  
+  //! Set ranked garside word factory
+  void set_ranked_garside_word_factory(RankedWordFactory rgwf);
+  
+  
 };
 
 //------
@@ -456,41 +461,48 @@ RightReversing::full_reverse(){
 //--------------
 
 inline
-MonoidFamily::MonoidFamily(string l,DisplayGenerator d,GeneratorsNumber n):label(l),gdisp(d),gnum(n){
-  left_reversing=nullptr;
-  right_reversing=nullptr;
+MonoidFamily::~MonoidFamily(){
 }
 
-
 inline string
 MonoidFamily::display() const{
   return label+" monoid family";
 }
 
+inline Word
+MonoidFamily::garside_element(size_t r){
+  return ranked_garside_word_factory(r);
+}
+
 inline size_t
 MonoidFamily::generators_number(size_t n){
   return gnum(n);
 }
 
-//-------------
-// MonoidTrait
-//-------------
-
-inline Word
-MonoidTrait::garside_element(size_t r){
-  return ranked_garside_word_factory(r);
-}
-
 inline bool
-MonoidTrait::has_garside_element() const{
+MonoidFamily::has_garside_element() const{
   return ranked_garside_word_factory!=nullptr;
 }
 
 inline bool
-MonoidTrait::has_garside_automorphism() const{
+MonoidFamily::has_garside_automorphism() const{
   return ranked_phi_germ!=nullptr;
 }
 
+inline void
+MonoidFamily::set_ranked_phi_germ(RankedGeneratorBijection rpg){
+  ranked_phi_germ=rpg;
+}
+
+inline void
+MonoidFamily::set_ranked_garside_word_factory(RankedWordFactory rgwf){
+  ranked_garside_word_factory=rgwf;
+}
+
+//-------------
+// MonoidTrait
+//-------------
+
 inline bool
 MonoidTrait::has_left_complement() const{
   return left_reversing!=nullptr;
@@ -593,16 +605,6 @@ MonoidTrait::set_right_complement(SetComplement sc){
   right_reversing=new RightReversing(sc);
 }
 
-inline void
-MonoidTrait::set_ranked_phi_germ(RankedGeneratorBijection rpg){
-  ranked_phi_germ=rpg;
-}
-
-inline void
-MonoidTrait::set_ranked_garside_word_factory(RankedWordFactory rgwf){
-  ranked_garside_word_factory=rgwf;
-}
-
 //------
 // Word
 //------