예제 #1
0
void clmCastActors
(  mclx**   mxpp        /* is made stochastic and has loops added */
,  mclx**   clpp        /* entries are set to self-value */
,  mclx**   el_to_clpp  /* transpose of cl            */
,  mclx**   el_on_clpp  /* will be made stochastic    */
,  mclx**   cl_on_clpp  /* will be made stochastic    */
,  mclx**   cl_on_elpp  /* transpose of stochastic el_on_cl */
,  double   frac        /* consider clusters in el_on_cl until frac
                               edge weight is covered */
)
   {  mclxAdjustLoops(*mxpp, mclxLoopCBmax, NULL)
   ;  mclxMakeStochastic(*mxpp)
   ;  *el_to_clpp =  mclxTranspose(*clpp)

                              /* el_to_cl not stochastic? */
   ;  *el_on_clpp =  mclxCompose(*el_to_clpp, *mxpp, 0, 1)
   ;  mclxMakeStochastic(*el_on_clpp)

   ;  *cl_on_clpp =  mclxCompose(*el_on_clpp, *clpp, 0, 1)
   ;  mclxMakeStochastic(*cl_on_clpp)

   ;  set_cl_to_projection(*clpp, *el_on_clpp)
   ;  prune_el_on_cl(*el_to_clpp, *el_on_clpp, frac, 10)
   ;  *cl_on_elpp =  mclxTranspose(*el_on_clpp)
;  }
예제 #2
0
파일: mclcm.c 프로젝트: ANS-math/SBEToolbox
static mclx* get_coarse
(  const mclx* mxbase
,  mclx* clprev
,  mcxbool add_transpose
)
   {  mclx* blockc   =  mclxBlocksC(mxbase, clprev)
   ;  mclx* clprevtp =  mclxTranspose(clprev)
   ;  mclx *p1       =  NULL     /* p_roduct */
   ;  mclx* mx_coarse=  NULL

   ;  mclxMakeStochastic(clprev)

/****************** <EXPERIMENTAL CRAP>  ************************************/
   ;  if (hdp_g)
      mclxUnary(clprev, fltxPower, &hdp_g)
                        /* parameter: use mxbase rather than blockc */
   ;  if (getenv("MCLCM_BLOCK_STOCHASTIC")) /* this works very badly! */
      mclxMakeStochastic(blockc)

   ;  else if (getenv("MCLCM_BASE_UNSCALE") && start_col_sums_g)
      {  dim i
      ;  for (i=0;i<N_COLS(blockc);i++)
         {  double f = start_col_sums_g->ivps[i].val
         ;  mclvUnary(blockc->cols+i, fltxMul, &f)
      ;  }
   ;  }
/****************** </EXPERIMENTAL> *****************************************/

      p1 = mclxCompose(blockc, clprev, 0)
;if (0)
{mcxIO* t = mcxIOnew("-", "w")
;mclxWrite(blockc, t, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL)
;
}
   ;  mclxFree(&blockc)
   ;  mx_coarse = mclxCompose(clprevtp, p1, 0) 
   ;  if (add_transpose)
      mclxAddTranspose(mx_coarse, 0.0)
   ;  mclxAdjustLoops(mx_coarse, mclxLoopCBremove, NULL)

   ;  mclxFree(&p1)
   ;  mclxFree(&clprevtp)

   ;  mclxMakeCharacteristic(clprev)
   ;  return mx_coarse
;  }