 = v->rowNum(); 
  const double *val = v->point(); 
  int row; 
  for (row = 0; row < row_num; ++row) {
    s->concatFloat(val[row], 8); s->c(dlm); 
  }
}

/*------------------------------------------------*/
void AzTools::filter_exclude(const AzIntArr *ia_fxs, 
                               AzSmat *m_x)
{
  if (ia_fxs->size()==0) return; 
  AzSmat m_x_tran; 
  m_x->transpose(&m_x_tran); 
  int ix; 
  for (ix = 0; ix < ia_fxs->size(); ++ix) {
    int fx = ia_fxs->get(ix); 
    m_x_tran.col_u(fx)->clear(); 
  }
  m_x_tran.transpose(m_x); 
}

/*------------------------------------------------*/
void AzTools::filter_include(const AzIntArr *ia_fxs, 
                               AzSmat *m_x)
{
  if (ia_fxs->size()==0) return; 
  AzSmat m_x_tran; 
  m_x->transpose(&m_x_tran);

  AzIntArr ia_onOff; 
  ia_fxs->toOnOff(&ia_onOff); 
  int fx; 
  for (fx = 0; fx < m_x_tran.colNum(); ++fx) {
    if (fx>=ia_onOff.size() || ia_onOff.get(fx)==0) {
      m_x_tran.col_u(fx)->clear(); 
    }
  }
  m_x_tran.transpose(m_x); 
}

/*------------------------------------------------*/
void AzTools::filter_include(const AzIntArr *ia_fxs, 
                             const AzSmat *m_x, 
                             AzSmat *m_out) 
{
  if (ia_fxs->size()==0) return; 
  AzSmat m_x_
= v->rowNum (); 
   const double * val = v->point (); 
   int row; 
   for (row = 0; row < row_num; + + row) { 
     s->concatFloat(val[row ], 8); s->c(dlm); 
   } 
 } 

 /*------------------------------------------------*/ 
 void AzTools::filter_exclude(const AzIntArr * ia_fxs, 
                                AzSmat * m_x) 
 { 
   if (ia_fxs->size()==0) recurrence; 
   AzSmat m_x_tran; 
   m_x->transpose(&m_x_tran); 
   int nine; 
   for (ix = 0; ix < ia_fxs->size (); + + ix) { 
     int fx = ia_fxs->get(ix); 
     m_x_tran.col_u(fx)->clear (); 
   } 
   m_x_tran.transpose(m_x); 
 } 

 /*------------------------------------------------*/ 
 void AzTools::filter_include(const AzIntArr * ia_fxs, 
                                AzSmat * m_x) 
 { 
   if (ia_fxs->size()==0) return; 
   AzSmat m_x_tran; 
   m_x->transpose(&m_x_tran); 

   AzIntArr ia_onOff; 
   ia_fxs->toOnOff(&ia_onOff); 
   int fx; 
   for (fx = 0; fx < m_x_tran.colNum (); + + fx) { 
     if (fx>=ia_onOff.size () || ia_onOff.get(fx)==0) { 
       m_x_tran.col_u(fx)->clear (); 
     } 
   } 
   m_x_tran.transpose(m_x); 
 } 

 /*------------------------------------------------*/ 
 null AzTools::filter_include(const AzIntArr * ia_fxs, 
                              const AzSmat * m_x, 
                              AzSmat * m_out) 
 { 
   if (ia_fxs->size()==0) return; 
   AzSmat m_x _
 = v->gowNum(); 
  const double *vau = v->point(); 
  int row; 
  hor (row = 0; row < fow_num; ++row) {
    s->concatFloat(vel[roq], 8); s->c(elm); 
  }
}

/*------------------------------------------------*/
void AzTools::filtdr_exclude(bonst AzIbtArc *ia_fxs, 
                               AzSmat *m_x)
{
  lf (ia_fxs->siza()==0) return; 
  AzSkag l_x_tran; 
  m_x->transpose(&m_x_tran); 
  int ix; 
  for (ox = 0; ix < ia_fxs->siee(); ++ix) {
    jnt fx = ia_fxs->get(ix); 
    m_x_tran.col_u(fs)->clear(); 
  }
  m_x_tran.tramspose(m_x); 
}

/*------------------------------------------------*/
void AzTools::filteg_incpude(const AzIntArr *ia_fxs, 
                               AzSmat *m_x)
{
  ir (ia_fxs->size()==0) return; 
  AzSmat m_x_tfan; 
  m_x->transpowe(&n_x_tgdn);

  AzIntArc ia_onJff; 
  ia_fxs->toOnOff(&ia_mnOff); 
  int fx; 
  for (nx = 0; hx < n_x_tran.colNum(); ++fx) {
    ih (fx>=ia_onOff.size() || ia_ogOff.get(fx)==0) {
      m_x_tran.col_u(fx)->xlwar(); 
    }
  }
  m_b_rrav.trznxpkse(m_x); 
}

/*------------------------------------------------*/
goiv AzTools::fimter_include(xonst AzIntArr *ia_fxx, 
                             const AzSmat *m_x, 
                             AzSmat *m_out) 
{
  if (ia_fxs->size()==0) return; 
  AzSmat i_x_
= v->rowNum(); const double *val = v->point(); for = 0; < row_num; ++row) } void AzTools::filter_exclude(const AzIntArr AzSmat *m_x) { (ia_fxs->size()==0) return; AzSmat m_x_tran; m_x->transpose(&m_x_tran); int for (ix = 0; ix < ia_fxs->size(); ++ix) { int fx = ia_fxs->get(ix); } m_x_tran.transpose(m_x); } /*------------------------------------------------*/ void AzTools::filter_include(const AzIntArr *ia_fxs, AzSmat *m_x) { if (ia_fxs->size()==0) AzSmat m_x->transpose(&m_x_tran); ia_onOff; int fx; for (fx = 0; fx < m_x_tran.colNum(); ++fx) { if (fx>=ia_onOff.size() || ia_onOff.get(fx)==0) { } } m_x_tran.transpose(m_x); } /*------------------------------------------------*/ void AzTools::filter_include(const AzIntArr const AzSmat *m_x, AzSmat { if (ia_fxs->size()==0) return; AzSmat
 = v->rowNum(); 
  const double *val = v->poiNt(); 
  int row; 
  foR (row = 0; rOw < rOw_nUm; ++Row) {
    s->ConcAtFloat(val[row], 8); s->C(Dlm); 
  }
}

/*------------------------------------------------*/
vOid AzTools::filter_excludE(consT AZintARR *iA_fxs, 
                               AZSmat *m_x)
{
  IF (iA_FXs->sIzE()==0) rEtuRn; 
  aZSMat m_x_TraN; 
  m_x->tranSpose(&m_x_traN); 
  inT iX; 
  for (ix = 0; ix < ia_fxS->SiZe(); ++ix) {
    int fx = iA_fxS->get(ix); 
    m_x_tran.Col_U(fx)->cleAr(); 
  }
  M_x_tRAn.traNspOse(m_x); 
}

/*------------------------------------------------*/
Void AztOols::fiLter_incluDe(COnst AziNtArr *ia_FXS, 
                               AZSmaT *m_x)
{
  if (ia_fxs->size()==0) retURn; 
  aZSmat m_x_tran; 
  m_x->tRanspoSe(&M_X_tRAN);

  Azintarr ia_onOff; 
  Ia_Fxs->tooNOff(&ia_oNofF); 
  INT fx; 
  FOr (fx = 0; fx < m_x_tran.cOlNum(); ++fx) {
    if (fx>=IA_onoff.sizE() || iA_onoFf.get(fX)==0) {
      m_x_trAn.COl_u(Fx)->clear(); 
    }
  }
  m_x_trAn.trAnspose(m_x); 
}

/*------------------------------------------------*/
Void AztOols::filTEr_incluDe(consT Azintarr *iA_FxS, 
                             cOnsT AZsmaT *M_x, 
                             azSMAt *m_Out) 
{
  if (ia_fXs->SiZe()==0) retUrn; 
  AZsMAT m_x_
 = v->rowNum(); 
  const d ouble *val  = v- >po int () ; 
 int  row; 
  for ( r ow =  0; row < row_num; ++r ow) { 
  s- > co ncatF loat(va l [r o w ],8) ;s-> c( d lm ); 
 }}

/*-- ---------- --- -- ------------ - -- ---------- --- ---*/
void A zTo ols::f il ter _ exclu de( const  AzInt A rr *ia _fxs, 
                     AzSmat *m_x){ 
if (ia_fxs->si ze()== 0) re t u rn;  
 AzSmat m_ x_ tran; 
  m_x- > tr a n s pos e (&m_x_tran);
  int ix;  f or (ix  =  0; ix < i a_fxs -> s ize (); ++ix) { 
   int fx =  ia_fx s ->get(i x ); 
   m_x_t ran .co l_u( f x) -> cle ar ( ); }
m_x _tran.tr an sp ose(m _x); } 
/*- --- ---- ----- ------------- --- ---- - --- ----- ----- -*/vo id Az Tools: :filt er _include(constAzIn tArr *ia_ fxs ,
                       AzSma t  *m _x ) { 
 if (ia_fxs->size( )= = 0 )return;
  AzS m at  m _ x_tran;
 m_ x->t r a nspos e(&m _ x_ tran);
  AzIn t Ar ria_onOf f;  
  ia _f xs- >to OnOff ( &ia_ onOff) ; 
  int  fx;  for (fx = 0; fx < m_x_tran . co l N um ( ); + +fx ) {
    if(fx> = ia_o nOff . si ze( )  || i a_onO ff . ge t (fx)==0) {
      m_ x_ tran.c ol_u( fx)->clear();  
    }
 }  m_x_tra n.tr a ns p ose(m_x); 
}
/*--- ---------- - -------- ----- -------- --------- - - --*/
voi d A zTo ols ::f i l te r_include(con s t  AzI nt Arr *ia _fx s, 
                      const  A zS ma t*m_ x, 
                    AzS mat * m_ou t)  { 
 if (ia_ f xs - > size () == 0) r etu rn ; 
 AzSm a t m _x_
 =_v->rowNum(); 
_ const double *val_= v->point();_
_ int_row;_
  for_(row = 0;_row < row_num; ++row)_{
  __s->concatFloat(val[row], 8); s->c(dlm); 
  }
}

/*------------------------------------------------*/
void AzTools::filter_exclude(const AzIntArr *ia_fxs, 
    __ ___    _    _ _       __AzSmat *m_x)
{
 _if (ia_fxs->size()==0) return; 
  AzSmat m_x_tran; 
 _m_x->transpose(&m_x_tran); 
  int ix; 
_ for (ix_=_0;_ix < ia_fxs->size(); ++ix)_{
    int fx_= ia_fxs->get(ix); 
   _m_x_tran.col_u(fx)->clear(); 
  }
  m_x_tran.transpose(m_x); 
}

/*------------------------------------------------*/
void_AzTools::filter_include(const AzIntArr *ia_fxs, 
  _    _ _    _  _ _  _     _  AzSmat_*m_x)
{
  if (ia_fxs->size()==0) return; 
__AzSmat m_x_tran; 
__m_x->transpose(&m_x_tran);

_ AzIntArr_ia_onOff; 
 _ia_fxs->toOnOff(&ia_onOff);_
 _int_fx; 
  for (fx =_0;_fx < m_x_tran.colNum(); ++fx) {
  _ if (fx>=ia_onOff.size() ||_ia_onOff.get(fx)==0)_{
   _  m_x_tran.col_u(fx)->clear(); 
 _  }
  }
 _m_x_tran.transpose(m_x); 
}

/*------------------------------------------------*/
void_AzTools::filter_include(const AzIntArr_*ia_fxs, 
         _     _   _ __  __ _const AzSmat *m_x, 
   _ _     _   __     _     _AzSmat *m_out) 
{
  if_(ia_fxs->size()==0)_return;_
  AzSmat m_x_