Пример #1
0
mcxstatus mcxIOexpectNum
(  mcxIO*        xf
,  long*         lngp
,  mcxOnFail     ON_FAIL
)
   {  int   n_read   =  0
   ;  int   n_conv   =  0
   ;  mcxstatus status = STATUS_OK

   ;  if (inbuffer(xf))
      buffer_spout(xf, "mcxIOexpectNum")

   ;  mcxIOskipSpace(xf)      /* keeps accounting correct */

   ;  errno = 0
   ;  n_conv   =  fscanf(xf->fp, "%ld%n", lngp, &n_read)

   ;  xf->bc += n_read  /* fixme do fscanf error handling */
   ;  xf->lo += n_read

   ;  if (1 != n_conv)
         mcxErr("mcxIOexpectNum", "parse error: expected to find integer")
      ,  status = STATUS_FAIL
   ;  else if (errno == ERANGE)
         mcxErr("mcxIOexpectNum", "range error: not in allowable range")
      ,  status = STATUS_FAIL

   ;  if (status)
      {  mcxIOpos(xf, stderr)
      ;  if (ON_FAIL == EXIT_ON_FAIL)
         mcxExit(1)
   ;  }

      return status
;  }
Пример #2
0
static mcxstatus cttyArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  mcxIOnewName(xfmx_g, val)
      ;  break
      ;

         case MY_OPT_ABC
      :  xfabc_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_OUT
      :  out_g = val
      ;  break
      ;

         case MY_OPT_INCLUDE_ENDS
      :  include_ends_g = TRUE
      ;  break
      ;

         case MY_OPT_LIST_NODES
      :  break
      ;

         case MY_OPT_littleG
      :  i_group =  atoi(val)
      ;  break
      ;

         case MY_OPT_G
      :  n_group_G =  atoi(val)
      ;  break
      ;

         case MY_OPT_T
      :  n_thread_l = (unsigned) atoi(val)
      ;  break
      ;

         case MY_OPT_MOD
      :  mod_up = TRUE
      ;  break
      ;

         default
      :  mcxExit(1)
      ;
   ;  }
      return STATUS_OK
;  }
Пример #3
0
int mcxIOexpect
(  mcxIO          *xf
,  const char     *str
,  mcxOnFail      ON_FAIL
)
   {  const char* s  =  str
   ;  int         c  =  0
   ;  int         d  =  0
   ;  int         n_trailing

  /*  
   *  no functional behaviour yet attached to this state change
   *  fixme: semantics for STDIN agree between stdlib and us?
  */

   ;  while
      (  c = (uchar) s[0]
      ,  
         (  c
         && (  d = mcxIOstep(xf)
            ,  c == d
            )
         )
      )
      s++

   ;  n_trailing = strlen(s)     /* truncintok */

   ;  if (c && ON_FAIL == EXIT_ON_FAIL)
      {  mcxErr("mcxIOexpect", "parse error: expected to see <%s>", str)
      ;  mcxIOpos(xf, stderr)
      ;  mcxExit(1)
   ;  }
      return n_trailing
;  }
Пример #4
0
void mcxDiagnosticsAttractor
(  const char*          ffn_attr
,  const mclMatrix*     clus2elem
,  const mcxDumpParam   dumpParam
)
   {  int         n_nodes     =  clus2elem->n_range
   ;  int         n_written   =  dumpParam->n_written
   ;  mclMatrix*  mtx_Ascore  =  mclxAllocZero(n_written, n_nodes)
   ;  mcxIO*      xfOut       =  mcxIOnew(ffn_atr, "w")
   ;  dim         d           =  0

   ;  if (mcxIOopen(xfOut, RETURN_ON_FAIL) == STATUS_FAIL)
      {  mclxFree(&mtx_Ascore)
      ;  mcxIOfree(&xfOut)
      ;  return
   ;  }

   ;  for(d=0; d<n_written; d++)
      {  mclMatrix*  iterand     =  *(dumpParam->iterands+d)
      ;  mclVector*  vec_Ascore  =  NULL

      ;  if (iterands->n_cols != n_nodes || iterand->n_range != n_nodes)
         {  fprintf(stderr, "mcxDiagnosticsAttractor: dimension error\n")
         ;  mcxExit(1)
      ;  }

         vec_Ascore  =  mcxAttractivityScale(iterand)
      ;  mclvRenew((mtx_Ascore->cols+d), vec_Ascore->ivps, vec_Ascore->n_ivps)
      ;  mclvFree(&vec_Ascore)
   ;  }

      mclxbWrite(mtx_Ascore, xfOut, RETURN_ON_FAIL)
   ;  mclxFree(mtx_Ascore)
;  }
Пример #5
0
mcxstatus mcxIOexpectReal
(  mcxIO*        xf
,  double*       dblp
,  mcxOnFail     ON_FAIL
)
   {  int   n_read   =  0
   ;  int   n_conv   =  0

   ;  if (inbuffer(xf))
      buffer_spout(xf, "mcxIOexpectReal")

   ;  mcxIOskipSpace(xf)      /* keeps accounting correct */

   ;  n_conv   =  fscanf(xf->fp, " %lf%n", dblp, &n_read)

   ;  xf->bc += n_read  /* fixme do fscanf error handling */
   ;  xf->lo += n_read

   ;  if (1 != n_conv)
      {  if (ON_FAIL == EXIT_ON_FAIL)
         {  mcxIOpos(xf, stderr)
         ;  mcxErr("parseReal", "parse error: expected to find real")
         ;  mcxExit(1)
      ;  }
         return STATUS_FAIL
   ;  }
      return STATUS_OK
;  }
Пример #6
0
void mclvRuntime
(  const mclVector* vec
,  const char* caller
)
   {  if (!vec)
         mcxErr(caller, "void vector argument")
      ,  mcxExit(1)
;  }
Пример #7
0
static mcxstatus collectArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_OUT
      :  out_g = val
      ;  break
      ;

         case MY_OPT_PASTE
      :  collect_g = 'p'
      ;  break
      ;

         case MY_OPT_NO_HEADER
      :  header_g = FALSE
      ;  break
      ;

         case MY_OPT_TRANSFORM
      :  transform_spec = mcxTingNew(val)
      ;  break
      ;

         case MY_OPT_MATRIX_MAX
      :  collect_g = 'm'
      ;  fltop_g = fltMax
      ;  break
      ;

         case MY_OPT_MATRIX_ADD
      :  collect_g = 'm'
      ;  break
      ;

         case MY_OPT_2COLUMN
      :  collect_g = 'c'
      ;  break
      ;

         case MY_OPT_SUMMARY
      :  summary_g = 1
      ;  break
      ;

         default
      :  mcxExit(1) 
      ;
      }
   ;  return STATUS_OK
;  }
Пример #8
0
int main
(  int               argc
,  const char*       argv[]
)
   {  int  a               =  0
   ;  mcxTing* argtxt      =  mcxTingEmpty(NULL, 10)

   ;  if (0)
      mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_NO)

   ;  opInitialize()       /* symtable etc */
   ;  globInitialize()     /* hdltable etc */

   ;  if (argc == 1)
      {  mcxTing* ops      =  mcxTingEmpty(NULL, 20)
      ;  mcxIO *xfin       =  mcxIOnew("-", "r")
      ;  mcxIOopen(xfin, EXIT_ON_FAIL)

      ;  fprintf
         (  stdout
         ,  "At your service: "
            "'[/<op>] help', '[/<str>] grep', 'ops', 'info', and 'quit'.\n"
         )

      ;  while (1)
         {  int ok
         ;  mcxTing* line  =  mcxTingEmpty(NULL, 30)

         ;  fprintf(stdout, "> ")
         ;  fflush(stdout)

         ;  if (STATUS_OK != mcxIOreadLine(xfin, line, MCX_READLINE_BSC))
            {  fprintf(stdout, "curtains!\n")
            ;  mcxTingFree(&line)
            ;  break
         ;  }
            mcxTingAppend(ops, line->str)
         ;  mcxTingFree(&line)

         ;  ok = zsDoSequence(ops->str)

         ;  if (ok && (v_g & V_STACK))
            zsList(0)

         ;  mcxTingEmpty(ops, 20)
      ;  }
      }
      else
      {  for (a=1;a<argc;a++)
         {  mcxTingWrite(argtxt, argv[a])
         ;  if (!zgUser(argtxt->str))
            mcxExit(1)
      ;  }
      }
      mcxTingFree(&argtxt)
   ;  return 0
;  }
Пример #9
0
static mcxstatus erdosArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  xfmx_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_PATH
      :  path_g = val
      ;  break
      ;

         case MY_OPT_STEP
      :  step_g = val
      ;  break
      ;

         case MY_OPT_OUT
      :  out_g = val
      ;  break
      ;

         case MY_OPT_ABC
      :  xfabc_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_ISUNDIRECTED
      :  input_status = 'u'
      ;  break
      ;

         case MY_OPT_ISDIRECTED
      :  input_status = 'd'
      ;  break
      ;

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_QUERY
      :  mcxIOnewName(xq_g, val)
      ;  break
      ;

         default
      :  mcxExit(1)
      ;
   ;  }
      return STATUS_OK
;  }
Пример #10
0
double mclvNorm
(  const mclVector*        vec
,  double                  power
)  
   {  if(power > 0.0)
         mcxErr("mclvNorm", "pbd: negative power argument <%f>", (double) power)
      ,  mcxExit(1)

   ;  return pow((double) mclvPowSum(vec, power), 1.0 / power)
;  }
Пример #11
0
int main
(  int               argc
,  const char*       argv[]
)
   {  const char* fn_input    =  argc > 1 ? argv[1] : ""
   ;  mclAlgParam* mlp        =  NULL
   ;  const char* me          =  "mcl"
   ;  mcxstatus status        =  STATUS_OK

   ;  srandom(mcxSeed(315))
   ;  signal(SIGALRM, mclSigCatch)
   ;  if (signal(SIGUSR1, mcxLogSig) == SIG_ERR)
      mcxErr(me, "cannot catch SIGUSR1!")

   ;  mcxLogLevel =
      MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
   ;  mclx_app_init(stderr)

   ;  if (argc < 2)
      {  mcxTell
         (  me
         ,  "usage: mcl <-|file name> [options],"
            " do 'mcl -h' or 'man mcl' for help"
         )
      ;  mcxExit(0)
   ;  }

      status
      =  mclAlgInterface
         (&mlp, (char**) (argv+2), argc-2, fn_input, NULL, ALG_DO_IO)

   ;  if (status == ALG_INIT_DONE)
      return 0
   ;  else if (status)
      mcxDie(STATUS_FAIL, me, "no tango")

   ;  if ((status = mclAlgorithm(mlp)) == STATUS_FAIL)
      mcxDie(STATUS_FAIL, me, "failed")

   ;  if (mlp->n_assimilated)
      mcxLog(MCX_LOG_MODULE, me, "%lu nodes will assimilate", (ulong) mlp->n_assimilated)

   ;  if (mlp->mx_start)
      mcxLog(MCX_LOG_MODULE, me, "cached matrix with %lu columns", (ulong) N_COLS(mlp->mx_start))

   ;  mclAlgParamFree(&mlp, TRUE)
   ;  helpful_reminder()
   ;  return STATUS_OK
;  }
Пример #12
0
static mcxstatus get_interface
(  mclAlgParam** mlpp
,  const char* fn_input          /* Use this as input or mx_input */
,  const char* arg_shared
,  const char* arg_extra
,  mclx* mx_input                /* Use this as input or fn_input */
,  mcxbits CACHE
,  mcxOnFail ON_FAIL
)
   {  mcxTing* spec  =  mcxTingNew(arg_shared)
   ;  int argc1      =  0
   ;  char** argv1
   ;  mcxstatus status
   ;  mclAlgParam* mymlp =  NULL
   ;  mclAlgParam** mymlpp = mlpp ? mlpp : &mymlp

   ;  if (arg_extra)
      mcxTingPrintAfter(spec, " %s", arg_extra)

                           /* warning this clobbers spec->str */
   ;  argv1 = mcxOptParseString(spec->str, &argc1, ' ')
   ;  status
      =  mclAlgInterface
         (  mymlpp
         ,  argv1
         ,  argc1
         ,  fn_input
         ,  mx_input
         ,  CACHE
         )
      
   ;  if (status && ON_FAIL == EXIT_ON_FAIL)
      mcxExit(1)

   ;  mcxFree(argv1)
   ;  mcxTingFree(&spec)
                     /* fixfixfixmefixmefffixme: mclAlgInterface might use opt->val
                      * which points to somewhere in spec->str. Check.
                     */

   ;  if (!mlpp)
      mclAlgParamFree(mymlpp, TRUE)

   ;  return status
;  }
Пример #13
0
static mcxstatus convertArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_BINARY
      :  mclxSetBinaryIO()
      ;  break
      ;

         case MY_OPT_CAT
      :  docat = TRUE         /* unused, idling */
      ;  main_mode = 'l'      /* level(s) */
      ;  break
      ;

         case MY_OPT_RO
      :  test_read = TRUE
      ;  break
      ;

         case MY_OPT_CATMAX
      :  catmax = atoi(val)
      ;  break
      ;

         case MY_OPT_S2C
      :  main_mode = 's'      /* stack to cone */
      ;  break
      ;

         case MY_OPT_C2S
      :  main_mode = 'c'      /* cone to stack */
      ;  break
      ;

         default
      :  mcxExit(1) 
      ;
      }
      return STATUS_OK
;  }
Пример #14
0
static mclx* get_base
(  const char* fn_input
,  mclx*       mx_input
,  const char* b1opts
,  const char* b2opts
)
   {  mclAlgParam* mlp =   NULL
   ;  mcxstatus status =   STATUS_FAIL
   ;  mclx* mxbase     =   NULL  

   ;  get_interface
      (  &mlp
      ,  fn_input
      ,  b2opts ? b2opts : b1opts
      ,  NULL
      ,  mx_input
      ,  b2opts ? ALG_CACHE_EXPANDED : ALG_CACHE_START
      ,  EXIT_ON_FAIL
      )

   ;  if (b2opts)
      {  mlp->mpp->mainLoopLength = 1
      ;  mlp->mpp->mainInflation = 1.0
      ;  mlp->expand_only = TRUE

      ;  mcxLog(MCX_LOG_APP, me, "computing expanded matrix")
      ;  if ((status = mclAlgorithm(mlp)) == STATUS_FAIL)
         {  mcxErr(me, "failed")
         ;  mcxExit(1)
      ;  }
         mcxLog(MCX_LOG_APP, me, "done computing expanded matrix")
      ;  mxbase = mclAlgParamRelease(mlp, mlp->mx_expanded)
   ;  }
      else
      {  if (mclAlgorithmStart(mlp, FALSE))
         mcxDie(1, me, "-b1 option start-up failed")
      ;  mxbase = mclAlgParamRelease(mlp, mlp->mx_start)
      ;  start_col_sums_g = mclvClone(mlp->mx_start_sums)
   ;  }
      mclAlgParamFree(&mlp, TRUE)
   ;  return mxbase
;  }
Пример #15
0
static mcxstatus alterArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  mcxIOnewName(xfmx_g, val)
      ;  break
      ;

         case MY_OPT_ABC
      :  xfabc_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_O
      :  mcxIOnewName(xfout_g, val)
      ;  break
      ;

         case MY_OPT_CANONICAL
      :  canonical_g = atoi(val)
      ;  break
      ;  

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_TRANSFORM
      :  transform_spec = mcxTingNew(val)
      ;  break
      ;

         default
      :  mcxExit(1)
      ;
   ;  }
      return STATUS_OK
;  }
Пример #16
0
mcxstatus  mcxIOopen
(  mcxIO*   xf
,  mcxOnFail      ON_FAIL
)
   {  const char* fname    =  xf->fn->str
   ;  if (!xf)
      {  mcxErr("mcxIOnew PBD", "received void object")
      ;  if (ON_FAIL == RETURN_ON_FAIL)
         return STATUS_FAIL
      ;  exit(1)
   ;  }

      if (mcxIOwarnOpenfp(xf, "mcxIOopen PBD"))
      return STATUS_OK

   ;  if (!strcmp(fname, "-"))
      {  if (strchr(xf->mode, 'r'))
         xf->fp =  stdin
      ;  else if (strchr(xf->mode, 'w') || strchr(xf->mode, 'a'))
         xf->fp =  stdout
   ;  }

      else if
      (  !strcmp(fname, "stderr")
      && (strchr(xf->mode, 'w') || strchr(xf->mode, 'a'))
      )
      xf->fp =  stderr

   ;  else if ((xf->fp = fopen(fname, xf->mode)) == NULL)
      {  if (ON_FAIL == RETURN_ON_FAIL)
         return STATUS_FAIL
      ;  mcxIOerr(xf, "mcxIOopen", "cannae be opened")
      ;  mcxExit(1)
   ;  }

      return STATUS_OK
;  }
Пример #17
0
int main
(  int                  argc
,  const char*          argv[]
)  
   {  mcxIO* xf1, *xf2
   ;  mclx* mx1, *mx2
   ;  mcxbits modes = 0

   ;  mcxLogLevel =
      MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
   ;  mclx_app_init(stdout)

   ;  if (argc < 4)
         mcxUsage(stdout, me, usagelines)
      ,  mcxExit(0)

   ;  modes =  atoi(argv[1])
   ;  xf1   =  mcxIOnew(argv[2], "r")
   ;  xf2   =  mcxIOnew(argv[3], "r")

   ;  mx1   =  mclxRead(xf1, EXIT_ON_FAIL)
   ;  mx2   =  mclxRead(xf2, EXIT_ON_FAIL)

   ;  pairwise_setops(mx1, mx2, modes)

   ;  if (modes & MMM_DUMPMX)
      {  mcxIO* xo = mcxIOnew("out.mmm", "w")
      ;  mclxWrite(mx1, xo, MCLXIO_VALUE_GETENV, RETURN_ON_FAIL)
   ;  }

      mclxFree(&mx1)
   ;  mclxFree(&mx2)
   ;  mcxIOfree(&xf1)
   ;  mcxIOfree(&xf2)
   ;  return 0
;  }
Пример #18
0
static mcxstatus meetMain
(  int                  argc
,  const char*          argv[]
)
   {  mcxIO          **xfmcs        =  NULL

   ;  mclMatrix      *lft           =  NULL
   ;  mclMatrix      *rgt           =  NULL
   ;  mclMatrix      *dst           =  NULL

   ;  int            a              =  0
   ;  int            n_mx           =  0
   ;  int            j
   ;  dim  o, m, e

   ;  mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES)
   ;  mclx_app_init(stderr)

   ;  xfmcs    =  (mcxIO**) mcxAlloc
                  (  (argc)*sizeof(mcxIO*)
                  ,  EXIT_ON_FAIL
                  )

   ;  mcxIOopen(xfout, EXIT_ON_FAIL)

   ;  for(j=a;j<argc;j++)
      {  xfmcs[n_mx] = mcxIOnew(argv[j], "r")
      ;  n_mx++
   ;  }

      if (!n_mx)
      mcxDie(1, me, "at least one clustering matrix required")

  /* Fixme: do a decent initialization with lft = clmTop() *before*
   * this loop (removing the need for ugly tmp assignment), but that requires
   * we know the correct domain to pass to it.  For that, we need to peak into
   * the first matrix.
  */

   ;  for (j=0;j<n_mx;j++)
      {  mclMatrix* tmp = mclxRead (xfmcs[j], EXIT_ON_FAIL)

      ;  if (clmEnstrict(tmp, &o, &m, &e, ENSTRICT_SPLIT_OVERLAP))
            report_partition("clmmeet", tmp, xfmcs[j]->fn, o, m, e)
         ,  mcxExit(1)

      ;  if (!lft)
         {  lft = tmp
         ;  continue
      ;  }
         else
         rgt = tmp

      ;  if (!MCLD_EQUAL(lft->dom_rows, rgt->dom_rows))
         mcxDie
         (  1
         ,  me
         ,  "domains not equal (files %s/%s)"
         ,  xfmcs[j-1]->fn->str
         ,  xfmcs[j]->fn->str
         )

      ;  mcxIOclose(xfmcs[j])

      ;  dst   =  clmMeet(lft, rgt)
      ;  lft   =  dst
      ;  mclxFree(&rgt)
   ;  }

      mclxColumnsRealign(lft, mclvSizeRevCmp)
   ;  mclxWrite(lft, xfout, MCLXIO_VALUE_NONE, EXIT_ON_FAIL)

   ;  mclxFree(&lft)
   ;  mcxIOfree(&xfout)
   ;  free(xfmcs)
   ;  return STATUS_OK
;  }
Пример #19
0
int main
(  int                  argc
,  const char*          argv[]
)  
   {  mcxIO
         *xfcl    =  NULL
      ,  *xfctrl  =  NULL
      ,  *xfcoarse=  NULL
      ,  *xfbase  =  NULL
      ,  *xfcone  =  NULL
      ,  *xfstack =  NULL

   ;  mclx* mxbase, *cl, *cl_coarse, *clprev, *clctrl = NULL

   ;  mcxTing* shared = mcxTingNew("-I 4 -overlap split")
   ;  mcxbool root = TRUE
   ;  mcxbool have_bootstrap = FALSE
   ;  const char* plexprefix = NULL
   ;  const char* stem = "mcl"
   ;  mcxbool same = FALSE
   ;  mcxbool plex = TRUE
   ;  mcxbool add_transpose = FALSE
   ;  const char* b2opts = NULL
   ;  const char* b1opts = NULL
   ;  mcxbits write_modes = 0

   ;  mclAlgParam* mlp        =  NULL
   ;  mcxstatus status        =  STATUS_OK
   ;  mcxstatus parse_status  =  STATUS_OK
   ;  int multiplex_idx = 1
   ;  int N = 0
   ;  int n_ite = 0
   ;  dim n_components = 0, n_cls = 0


   ;  int a =  1, i= 0
   ;  int n_arg_read = 0
   ;  int delta = 0
   ;  mcxOption* opts, *opt
   ;  mcxTing* cline = mcxOptArgLine(argv+1, argc-1, '\'')
   ;  mclgTF* transform  =  NULL
   ;  mcxTing* transform_spec = NULL


   ;  double iaf = 0.84

   ;  mclx_app_init(stderr)

   ;  if (0)
      mcxLogLevel =
      MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
   ;  else
      mcxLogLevelSetByString("xf4g1")

   ;  mcxOptAnchorSortById(options, sizeof(options)/sizeof(mcxOptAnchor) -1)

   ;  if (argc == 2 && argv[1][0] == '-' && mcxOptIsInfo(argv[1], options))
      delta = 1
   ;  else if (argc < 2)
      {  help(options, shared)
      ;  exit(0)
   ;  }

      opts = mcxOptExhaust
            (options, (char**) argv, argc, 2-delta, &n_arg_read, &parse_status)

   ;  if (parse_status != STATUS_OK)
      {  mcxErr(me, "initialization failed")
      ;  exit(1)
   ;  }

   ;  for (opt=opts;opt->anch;opt++)
      {  mcxOptAnchor* anch = opt->anch

      ;  switch(anch->id)
         {  case MY_OPT_HELP
         :  help(options, shared)
         ;  exit(0)
         ;

            case MY_OPT_APROPOS
         :  help(options, shared)
         ;  exit(0)
         ;  break
         ;

            case MY_OPT_NMAX
         :  N = atoi(opt->val)
         ;  break
         ;

            case MY_OPT_Z
         :  help(NULL, shared)
         ;  exit(0)
         ;  break
         ;

            case MY_OPT_SHARED
         :  mcxTingPrintAfter(shared, " %s", opt->val)
         ;  break
         ;

            case MY_OPT_TRANSFORM
         :  transform_spec = mcxTingNew(opt->val)
         ;  break
         ;

            case MY_OPT_B1
         :  b1opts = opt->val
         ;  break
         ;

            case MY_OPT_B2
         :  b2opts = opt->val
         ;  break
         ;

            case ALG_OPT_SETENV
         :  mcxSetenv(opt->val)
         ;  break
         ;

            case ALG_OPT_QUIET
         :  mcxLogLevelSetByString(opt->val)
         ;  break
         ;

            case MY_OPT_HDP
         :  hdp_g = atof(opt->val)
         ;  break
         ;

            case MY_OPT_ADDTP
         :  add_transpose = TRUE
         ;  break
         ;

            case MY_OPT_ANNOT       /* only used in command-line copying */
         :  break
         ;

            case MY_OPT_IAF
         :  iaf = atof(opt->val) / 100
         ;  break
         ;

            case MY_OPT_WRITE
         :  if (strstr(opt->val, "stack"))
            write_modes |= OUTPUT_STACK
         ;  if (strstr(opt->val, "cone"))
            write_modes |= OUTPUT_CONE
         ;  if (strstr(opt->val, "levels"))
            write_modes |= OUTPUT_STEPS
         ;  if (strstr(opt->val, "coarse"))
            write_modes |= OUTPUT_COARSE
         ;  if (strstr(opt->val, "base"))
            write_modes |= OUTPUT_BASE
         ;  break
         ;

            case MY_OPT_BASENAME
         :  xfbase = mcxIOnew(opt->val, "w")
         ;  break
         ;

            case MY_OPT_COARSE
         :  xfcoarse = mcxIOnew(opt->val, "w")
         ;  break
         ;

            case MY_OPT_CONE
         :  xfcone = mcxIOnew(opt->val, "w")
         ;  break
         ;

            case MY_OPT_ROOT
         :  root = strchr("1yY", (u8) opt->val[0]) ? TRUE : FALSE
         ;  break
         ;

            case MY_OPT_STACK
         :  xfstack = mcxIOnew(opt->val, "w")
         ;  break
         ;

            case MY_OPT_STEM
         :  stem = opt->val
         ;  break
         ;

            case MY_OPT_MULTIPLEX
         :  plex = strchr("yY1", (unsigned char) opt->val[0]) ? TRUE : FALSE
         ;  break
         ;

            case MY_OPT_DISPATCH
         :  dispatch_g = TRUE
         ;  break
         ;

            case MY_OPT_INTEGRATE
         :  integrate_g = TRUE
         ;  break
         ;

            case MY_OPT_CONTRACT
         :  break
         ;

            case MY_OPT_SUBCLUSTERX
         :  subclusterx_g = TRUE,  subcluster_g = TRUE
         ;  break
         ;

            case MY_OPT_SUBCLUSTER
         :  subcluster_g = TRUE
         ;  break
         ;

            case MY_OPT_CONTROL
         :  xfctrl = mcxIOnew(opt->val, "r")
         ;  break
         ;

            case MY_OPT_CL
         :  xfcl = mcxIOnew(opt->val, "r")
         ;  have_bootstrap = TRUE
         ;  break
         ;

            case MY_OPT_VERSION
         :  app_report_version(me)
         ;  exit(0)
         ;

            default
         :  mcxExit(1)
         ;
         }
      }

      mcxOptFree(&opts)

   ;  a = 2 + n_arg_read

   ;  if (a < argc)
      {  if (strcmp(argv[a], "--"))
         mcxDie
         (  1
         ,  me
         ,  "trailing %s options require standalone '--' separator (found %s)"
         ,  integrate_g ? "integrate" : "mcl"
         ,  argv[a]
         )
      ;  a++
   ;  }

      if (subcluster_g + dispatch_g + integrate_g > 1)
      mcxDie(1, me, "too many modes!")

   ;  if (N && N < argc-a)
      mcxErr(me, "-n argument leaves spurious option specifications")

   ;  srandom(mcxSeed(89315))
   ;  signal(SIGALRM, mclSigCatch)

   ;  if (dispatch_g)
      plexprefix = "dis"
   ;  else if (!write_modes || (write_modes & OUTPUT_STEPS))
      plexprefix = stem

   ;  {  mcxTing* tg = mcxTingEmpty(NULL, 30)
      ;  if ((write_modes & OUTPUT_COARSE) && !xfcoarse)
            mcxTingPrint(tg, "%s.%s", stem, "coarse")
         ,  xfcoarse = mcxIOnew(tg->str, "w")

      ;  if ((write_modes & OUTPUT_BASE) && !xfbase)
            mcxTingPrint(tg, "%s.%s", stem, "base")
         ,  xfbase = mcxIOnew(tg->str, "w")

      ;  if
         (  (!write_modes || (write_modes & OUTPUT_CONE))
         && !xfcone
         )
         {  mcxTingPrint(tg, "%s.%s", stem, "cone")
         ;  xfcone = mcxIOnew(tg->str, "w")
         ;  mcxIOopen(xfcone, EXIT_ON_FAIL)
         ;  fprintf(xfcone->fp, "# %s %s\n", argv[0], cline->str)
      ;  }

         if ((write_modes & OUTPUT_STACK) && !xfstack)
         {  mcxTingPrint(tg, "%s.%s", stem, "stack")
         ;  xfstack = mcxIOnew(tg->str, "w")
         ;  mcxIOopen(xfstack, EXIT_ON_FAIL)
         ;  fprintf(xfstack->fp, "# %s %s\n", argv[0], cline->str)
      ;  }

         mcxTingFree(&tg)
   ;  }

      if (integrate_g)
      {  for (i=a;i<argc;i++)
         {  mcxIO* xf = mcxIOnew(argv[i], "r")
         ;  mclx* cl = mclxRead(xf, EXIT_ON_FAIL)
         ;  mclxCatPush(&stck_g, cl, NULL, NULL, mclxCBdomStack, NULL, "dummy-integrate", n_cls++)
      ;  }

         integrate_results(&stck_g)

      ;  if (xfstack)
         mclxCatWrite(xfstack, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL)

      ;  if (xfcone)
            mclxCatConify(&stck_g)
         ,  mclxCatWrite(xfcone, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL)

      ;  return 0
   ;  }

      for (i=a;i<argc;i++)
      {  if (get_interface(NULL, argv[1], shared->str, argv[i], NULL, 0, RETURN_ON_FAIL))
         mcxDie(1, me, "error while testing mcl options viability (%s)", argv[i])
   ;  }


      mcxLog(MCX_LOG_APP, me, "pid %ld", (long) getpid())

                        /* make sure clusters align with this cluster
                         * status: does not seem promising.
                        */
   ;  if (xfctrl)
      clctrl = mclxRead(xfctrl, EXIT_ON_FAIL)
   ;

                        /*
                         * Below: compute cl and mxbase.
                        */
   ;  if (xfcl)
      {  cl = mclxRead(xfcl, EXIT_ON_FAIL)
      ;  write_clustering
         (cl, NULL, xfcone, xfstack, plexprefix, multiplex_idx++, NULL)

      ;  if (subcluster_g || dispatch_g)
         mclxCatPush(&stck_g, cl, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++)

      ;  mcxIOfree(&xfcl)
      ;  if (!b1opts && !b2opts)
         b1opts = ""
      ;  mxbase = get_base(argv[1], NULL, b1opts, b2opts)
   ;  }
      else
      {  mcxbits CACHE  =     b1opts || b2opts
                           ?  ALG_CACHE_INPUT       /* cache, transform later */
                           :  ALG_CACHE_START
      ;  get_interface
         (  &mlp
         ,  argv[1]
         ,  shared->str
         ,  a < argc ? argv[a] : NULL
         ,  NULL
         ,  CACHE
         ,  EXIT_ON_FAIL
         )
      ;  if (a < argc)
         a++

      ;  if ((status = mclAlgorithm(mlp)) == STATUS_FAIL)
         {  mcxErr(me, "failed at initial run")
         ;  exit(1)
      ;  }

         cl_coarse =  mclAlgParamRelease(mlp, mlp->cl_result)
      ;  cl_coarse =  control_test(cl_coarse, clctrl)

      ;  write_clustering
         (cl_coarse, NULL, xfcone, xfstack, plexprefix, multiplex_idx++, mlp)

      ;  if (subcluster_g || dispatch_g)
         mclxCatPush(&stck_g, cl_coarse, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++)

      ;  cl = cl_coarse
      ;  n_ite++

      ;  if (b1opts || b2opts)
         {  mclx* mx_input =  mclAlgParamRelease(mlp, mlp->mx_input)
         ;  mxbase = get_base(NULL, mx_input, b1opts, b2opts)
                           /* ^ get_base frees mx_input */
      ;  }
         else
         mxbase =  mclAlgParamRelease(mlp, mlp->mx_start)
   ;  }

      clprev = cl

   ;  mclAlgParamFree(&mlp, TRUE)

   ;  if (xfbase)
      {  dim nre = mclxNrofEntries(mxbase)
      ;  mcxLog(MCX_LOG_APP, me, "base has %lu entries", (ulong) nre)
      ;  mclxaWrite(mxbase, xfbase, MCLXIO_VALUE_GETENV, EXIT_ON_FAIL)
      ;  mcxIOclose(xfbase)
   ;  }

      if (subcluster_g || dispatch_g)
      iaf = iaf ? 1/iaf : 1.414

   ;  while
      (  (!dispatch_g && (!N || n_ite < N))
      || (dispatch_g && a < argc)
      )
      {  mclx* mx_coarse   =  NULL, *clnext = NULL

      ;  dim dist_new_prev = 0, dist_prev_new = 0
      ;  mclx* clnew = NULL
      ;  mcxbool faith = FALSE
      ;  double inflation = -1.0

      ;  if (subcluster_g)
         mx_coarse
         =     subclusterx_g
            ?  mclxBlockPartition(mxbase, clprev, 50)
            :  mclxBlockUnion(mxbase, clprev)

                  /* have to copy mxbase as mx_coarse is freed.
                   * Even if it were not freed, it is probably transformed.
                  */
      ;  else if (dispatch_g)
         mx_coarse = mclxCopy(mxbase)

      ;  else
         {  mx_coarse = get_coarse(mxbase, clprev, add_transpose)

         ;  if (n_ite == 1)
            {  mclx* cc = clmUGraphComponents(mx_coarse, NULL)   /* fixme; mx_coarse garantueed UD ? */
            ;  n_components = N_COLS(cc)
            ;  mclxFree(&cc)
         ;  }
         }

         if (xfcoarse)
         write_coarse(xfcoarse, mx_coarse)

      ;  get_interface
         (  &mlp
         ,  NULL
         ,  shared->str
         ,  a < argc ? argv[a] : NULL
         ,  mx_coarse
         ,  ALG_CACHE_START
         ,  EXIT_ON_FAIL
         )

      ;  inflation = mlp->mpp->mainInflation
      ;  BIT_OFF(mlp->modes, ALG_DO_SHOW_PID | ALG_DO_SHOW_JURY)

      ;  if ((status = mclAlgorithm(mlp)) == STATUS_FAIL)
         {  mcxErr(me, "failed")
         ;  mcxExit(1)
      ;  }

         cl_coarse = mclAlgParamRelease(mlp, mlp->cl_result)

      ;  if (xfcoarse)
         mclxaWrite(cl_coarse, xfcoarse, MCLXIO_VALUE_NONE, RETURN_ON_FAIL)

      ;  if (dispatch_g || subcluster_g)
         clnext = cl_coarse
      ;  else
            clnext = mclxCompose(clprev, cl_coarse, 0)
         ,  clnext = control_test(clnext, clctrl)
         ,  mclxFree(&cl_coarse)

      ;  clmSJDistance
         (clprev, clnext, NULL, NULL, &dist_prev_new, &dist_new_prev)

      ;  if (dist_prev_new + dist_new_prev)
         {  write_clustering
            (clnext, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, mlp)
         ;  clnew = clnext

         ;  if (subcluster_g || dispatch_g)
            mclxCatPush(&stck_g, clnext, NULL, NULL, mclxCBdomStack, NULL, "dummy-mclcm", n_cls++)
         ;  else
            mclxFree(&clprev)

         ;  clprev = clnew
      ;  }
         else if
         (  N_COLS(clnext) > n_components
         && inflation * iaf > 1.2
         && inflation * iaf < 10
         )
         {  mclxFree(&clnext)
         ;  inflation *= iaf
         ;  mcxTingPrintAfter(shared, " -I %.2f", inflation)
         ;  mcxLog(MCX_LOG_APP, me, "setting inflation to %.2f", inflation)
         ;  faith = TRUE
      ;  }
                                       /* i.e. vanilla mode, contraction */
         else if (!subcluster_g && !dispatch_g)
         {  mclx* cc
         ;  mclxFree(&clnext)

         ;  mclxAddTranspose(mx_coarse, 1.0)
         ;  cc = clmUGraphComponents(mx_coarse, NULL)  

         ;  if (N_COLS(cc) < N_COLS(clprev))
            {  mclx* ccback = mclxCompose(clprev, cc, 0)
            ;  write_clustering
               (ccback, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, NULL)
            ;  mclxFree(&clprev)
            ;  clprev = ccback
            ;  mcxTell(me, "connected components added as root clustering")
         ;  }

            if (root && N_COLS(cc) > 1)
            {  mclx* root =   mclxCartesian
                              (  mclvCanonical(NULL, 1, 0)
                              ,  mclvCopy(NULL, mxbase->dom_cols)
                              ,  1.0
                              )
            ;  write_clustering
               (root, clprev, xfcone, xfstack, plexprefix, multiplex_idx++, NULL)

            ;  mclxFree(&clprev)

            ;  mcxTell(me, "universe added as root clustering")
            ;  clprev = root
            ;  clnew = NULL
         ;  }

            mclxFree(&cc)
      ;  }
         else if (subcluster_g || dispatch_g)
         mclxFree(&clnext)

      ;  mclAlgParamFree(&mlp, TRUE)                        /* frees mx_coarse */

      ;  if (!clnew && !faith)
         {  same = TRUE
         ;  break
      ;  }

         a++

      ;  if (dispatch_g && a == argc)
         break

      ;  n_ite++
   ;  }

      if (same)
      mcxLog(MCX_LOG_MODULE, me, "no further contraction: halting")

   ;  if (dispatch_g)
      integrate_results(&stck_g)
   ;  else if (subcluster_g)
      mclxCatReverse(&stck_g)

   ;  if (dispatch_g || subcluster_g)
      {  dim j
      ;  if (xfstack)
         mclxCatWrite(xfstack, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL)
      ;  if (xfcone && ! mclxCatConify(&stck_g))
         mclxCatWrite(xfcone, &stck_g, MCLXIO_VALUE_NONE, RETURN_ON_FAIL)
      ;  for (j=0;j<stck_g.n_level;j++)
         {  mclxAnnot* an = stck_g.level+j
         ;  mclxFree(&an->mx)
      ;  }
         mcxFree(stck_g.level)
   ;  }

      mcxIOfree(&xfcoarse)
   ;  mcxIOfree(&xfbase)
   ;  mcxIOfree(&xfcone)
   ;  mcxIOfree(&xfstack)

   ;  mcxTingFree(&shared)

   ;  if (!dispatch_g && !subcluster_g)          /* fixme fixme fixme */
      mclxFree(&clprev)

   ;  mclxFree(&mxbase)
   ;  mclvFree(&start_col_sums_g)
   ;  mcxTingFree(&cline)
   ;  helpful_reminder()
   ;  return STATUS_OK
;  }
Пример #20
0
static mcxstatus diameterArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  mcxIOnewName(xfmx_g, val)
      ;  break
      ;

         case MY_OPT_LIST_NODES
      :  list_nodes = TRUE
      ;  break
      ;

         case MY_OPT_T
      :  n_thread_l = (unsigned) atoi(val)
      ;  break
      ;

         case MY_OPT_LIST_MAX
      :  list_nodes = FALSE
      ;  break
      ;

         case MY_OPT_ROUGH
      :  rough = TRUE
      ;  break
      ;

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_OUT
      :  out_g = val
      ;  break
      ;

         case MY_OPT_littleG
      :  i_group =  atoi(val)
      ;  break
      ;

         case MY_OPT_G
      :  n_group_G =  atoi(val)
      ;  break
      ;

         case MY_OPT_ABC
      :  xfabc_g = mcxIOnew(val, "r")
      ;  break
      ;

         default
      :  mcxExit(1) 
      ;
   ;  }
      return STATUS_OK
;  }
Пример #21
0
mcxstatus sharedArgHandle
(  int optid
,  const char* val
,  mcxDispHook*   hook
,  mcxDispBundle* bundle
)
   {  mcxTing* full_syntax = mcxTingPrint(NULL, "%s %s", "clm", hook->syntax)
   ;  switch(optid)
      {  case CLM_DISP_HELP
      :  case CLM_DISP_APROPOS
      :  case CLM_DISP_AMOIXA
      :  
         mcxOptApropos
         (  stdout
         ,  hook->name
         ,  full_syntax->str
         ,  15
         ,  0
         ,  bundle->disp_shared
         )
      ;  mcxOptApropos
         (  stdout
         ,  hook->name
         ,  NULL
         ,  15
         ,     MCX_OPT_DISPLAY_SKIP
            |  (  optid == CLM_DISP_AMOIXA
               ?  MCX_OPT_DISPLAY_HIDDEN
               :  0
               )
         ,  hook->options
         )
      ;  mcxExit(0)
      ;  break
      ;

         case CLM_DISP_VERSION
      :  bundle->disp_version(hook->name)
      ;  mcxExit(0)
      ;  break
      ;

         case CLM_DISP_NOP
      :  NOTHING
      ;  break
      ;

         case CLM_DISP_TEST
      :  mcx_test_g = TRUE
      ;  break
      ;

         case CLM_DISP_PROGRESS
      :  mcx_progress_g = atoi(val)
      ;  break
      ;

         case CLM_DISP_PROGRESS2
      :  mcx_progress_g = 1
      ;  break
      ;

         case CLM_DISP_DEBUG
      :  mcx_debug_g = atoi(val)
      ;  break
      ;

         case CLM_DISP_DEBUG2
      :  mcx_debug_g = -1u
      ;  break
      ;

         case CLM_DISP_SET
      :  mcxSetenv(val)
      ;  break
      ;

         default
      :  break
      ;
      }
      mcxTingFree(&full_syntax)
   ;  return STATUS_OK
;  }
Пример #22
0
static mcxstatus qArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  mcxIOnewName(xfmx_g, val)
      ;  user_imx = TRUE
      ;  break
      ;

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_ICL
      :  xfcl_g =  mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_TRANSFORM
      :  transform_spec = mcxTingNew(val)
      ;  break
      ;

         case MY_OPT_DIMENSION
      :  mode_get = 'd'
      ;  break
      ;

         case MY_OPT_TESTCYCLE
      :  mode_get = 'c'
      ;  break
      ;

         case MY_OPT_TESTCYCLE_N
      :  n_limit = atoi(val)
      ;  mode_get = 'c'
      ;  break
      ;

         case MY_OPT_CLCF
      :  doclcf_g = TRUE
      ;  break
      ;

         case MY_OPT_KNNREDUCE
      :  knnexact_g = FALSE
      ;  break
      ;

         case MY_OPT_THREAD
      :  n_thread_g = atoi(val)
      ;  break
      ;

         case MY_OPT_NODE
      :  mode_get = 'n'
      ;  break
      ;

         case MY_OPT_FOUT
      :  mcxIOnewName(xfout_g, val)
      ;  break
      ;

         case MY_OPT_WEIGHT_SCALE
      :  weight_scale = atof(val)
      ;  break
      ;

         case MY_OPT_OUTPUT_TABLE
      :  output_table = TRUE
      ;  break
      ;

         case MY_OPT_MYTH
      :  weefreemen = TRUE
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS
      :  mode_get = 'e'
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS_HIST
      :  mode_get = 'H'
      ;  if (4 != sscanf(val, "%d,%d,%d,%d", &vary_a, &vary_z, &vary_s, &vary_n))
         mcxDie(1, me, "failed to parse argument as integers start,end,step,norm")
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS_SORTED
      :  mode_get = 'E'
      ;  break
      ;

         case MY_OPT_DIVIDE
      :  divide_g = atoi(val)
      ;  break
      ;

         case MY_OPT_VARY_CORRELATION
      :  vary_a = 4
      ;  vary_z = 20
      ;  vary_s = 1
      ;  vary_n = 20
      ;  weight_scale = 100
      ;  mode_vary = 'c'
      ;  break
      ;

         case MY_OPT_VARY_KNN
      :  if (4 != sscanf(val, "%d,%d,%d,%d", &vary_a, &vary_z, &vary_s, &vary_n))
         mcxDie(1, me, "failed to parse argument as integers start,end,step,norm")
      ;  mode_vary = 'k'
      ;  break
      ;

         case MY_OPT_VARY_THRESHOLD
      :  if (4 != sscanf(val, "%u,%u,%u,%u", &vary_a, &vary_z, &vary_s, &vary_n))
         mcxDie(1, me, "failed to parse argument as integers start,end,step,norm")
      ;  mode_vary = 't'
      ;  break
      ;

         default
      :  mcxExit(1) 
      ;
   ;  }

      if (mode_vary && 1000 * vary_s < vary_z - vary_a)
      mcxDie(1, me, "argument leads to more than one thousand steps")

   ;  if (!vary_n)
      mcxDie(1, me, "need nonzero scaling factor (last component)")

   ;  return STATUS_OK
;  }
Пример #23
0
static mcxstatus qArgHandle
(  int optid
,  const char* val
)
   {  switch(optid)
      {  case MY_OPT_IMX
      :  mcxIOnewName(xfmx_g, val)
      ;  user_imx = TRUE
      ;  break
      ;

         case MY_OPT_ABC
      :  xfabc_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_TAB
      :  xftab_g = mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_ICL
      :  xfcl_g =  mcxIOnew(val, "r")
      ;  break
      ;

         case MY_OPT_TRANSFORM
      :  transform_spec = mcxTingNew(val)
      ;  break
      ;

         case MY_OPT_DIMENSION
      :  mode_get = 'd'
      ;  break
      ;

         case MY_OPT_TESTMETRIC
      :  mode_get = 'm'
      ;  break
      ;

         case MY_OPT_TESTCYCLE
      :  mode_get = 'c'
      ;  break
      ;

         case MY_OPT_TESTCYCLE_N
      :  n_limit = atoi(val)
      ;  mode_get = 'c'
      ;  break
      ;

         case MY_OPT_INFO
      :  compute_flags |= COMPUTE_EFF
      ;  break
      ;

         case MY_OPT_CLCF
      :  compute_flags |= COMPUTE_CLCF
      ;  break
      ;

         case MY_OPT_REDUCE
      :  rebase_g = FALSE
      ;  break
      ;

         case MY_OPT_THREAD
      :  n_thread_l = atoi(val)
      ;  break
      ;

         case MY_OPT_NODE
      :  mode_get = 'n'
      ;  break
      ;

         case MY_OPT_FOUT
      :  mcxIOnewName(xfout_g, val)
      ;  break
      ;

         case MY_OPT_WEIGHT_SCALE
      :  weight_scale = atof(val)
      ;  break
      ;

         case MY_OPT_OUTPUT_NOLEGEND
      :  output_flags ^= OUTPUT_KEY
      ;  break
      ;

         case MY_OPT_OUTPUT_TABLE
      :  output_flags |= OUTPUT_TABLE
      ;  break
      ;

         case MY_OPT_SCALEFREE
      :  weefreemen = TRUE
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS
      :  mode_get = 'e'
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS_HIST
      :  mode_get = 'H'
      ;  if (4 != sscanf(val, "%d,%d,%d,%d", &vary_a, &vary_z, &vary_s, &vary_n))
         mcxDie(1, me, "failed to parse argument as integers start,end,step,norm")
      ;  break
      ;

         case MY_OPT_EDGEWEIGHTS_SORTED
      :  mode_get = 'E'
      ;  break
      ;

         case MY_OPT_DIVIDE
      :  divide_g = atoi(val)
      ;  break
      ;

         case MY_OPT_VARY_CORRELATION
      :  vary_a = 4
      ;  vary_z = 20
      ;  vary_s = 1
      ;  vary_n = 20
      ;  weight_scale = 100
      ;  mode_vary = 'c'
      ;  break
      ;

         case MY_OPT_VARY_CEIL
      :  case MY_OPT_VARY_KNN
      :  case MY_OPT_VARY_N
      :  case MY_OPT_VARY_THRESHOLD
      :  if (4 != sscanf(val, "%d,%d,%d,%d", &vary_a, &vary_z, &vary_s, &vary_n))
         mcxDie(1, me, "failed to parse argument as integers start,end,step,norm")
      ;  mode_vary
         =     optid == MY_OPT_VARY_THRESHOLD
            ?  't'
            :  optid == MY_OPT_VARY_KNN
            ?  'k'
            :  optid == MY_OPT_VARY_CEIL
            ?  'n'
            :  optid == MY_OPT_VARY_N
            ?  'l'
            :  'X'
      ;  break
      ;

         default
      :  mcxExit(1) 
      ;
   ;  }

      if (mode_vary && 1000 * vary_s < vary_z - vary_a)
      mcxDie(1, me, "argument leads to more than one thousand steps")

   ;  if (!vary_n)
      mcxDie(1, me, "need nonzero scaling factor (last component)")

   ;  return STATUS_OK
;  }
Пример #24
0
mcxstatus mclvCheck
(  const mclVector*        vec
,  long                    min
,  long                    max
,  mcxbits                 bits
,  mcxOnFail               ON_FAIL
)  
   {  mclIvp*  ivp      =  vec->ivps
   ;  mclIvp*  ivpmax   =  vec->ivps+vec->n_ivps
   ;  long     last     =  -1
   ;  const char* me    =  "mclvCheck"
   ;  mcxbool  ok       =  TRUE

   ;  if (vec->n_ivps && !vec->ivps)
         mcxErr(me, "deadly: NULL ivps and %ld n_ivps", (long) vec->n_ivps)
      ,  ok = FALSE
   ;  else if (vec->n_ivps && min >= 0 && MCLV_MINID(vec) < min)
         mcxErr
         (me, "daemons: MINID %ld less than %ld", (long) MCLV_MINID(vec), min)
      ,  ok = FALSE

   ;  while (ok && ivp<ivpmax)
      {  if (ivp->idx <= last)
         {  mcxErr(me, "deadly: index %s <%ld, %ld> at ivp <%ld>"
            ,  ivp->idx == last ? "repeat" : "descent"
            ,  (long) last
            ,  (long) ivp->idx
            ,  (long) (ivp - vec->ivps)
            )
         ;  ok = FALSE
         ;  break
      ;  }

         if
         (  (bits & MCLV_CHECK_POSITIVE && ivp->val < 0.0)
         || (bits & MCLV_CHECK_NONZERO && ivp->val == 0.0)
         )
         {  mcxErr(me, "error: value <%f> at ivp <%ld>"
            ,  (double) ivp->val
            ,  (long) (ivp - vec->ivps)
            )
         ;  ok = FALSE
         ;  break
      ;  }

         last = ivp->idx
      ;  ivp++
   ;  }

      if (ok && max >= 0 && last > max)
      {  mcxErr
         (  me
         ,  "deadly: index <%ld> tops range <%ld> at ivp <%ld>"
         ,  (long) last
         ,  (long) max
         ,  (long) (ivp - 1 - vec->ivps)
         )
      ;  ok    =  FALSE
   ;  }

      if (!ok && (ON_FAIL == EXIT_ON_FAIL))
      mcxExit(1)

   ;  return ok ? STATUS_OK : STATUS_FAIL
;  }
Пример #25
0
double mclvKBar
(  mclVector   *vec
,  dim         k
,  double      ignore            /*    ignore elements relative to this  */
,  int         mode
)  
   {  int      have_even   =  (k+1) % 2
   ;  dim      n_inserted  =  0
   ;  double   ans         =  0.0
   ;  mclIvp * vecivp      =  vec->ivps
   ;  mclIvp*  vecmaxivp   =  vecivp + vec->n_ivps
   ;  pval *   heap
                                 /* can select everything */
   ;  if (k >= vec->n_ivps)
      return mode == KBAR_SELECT_LARGE ? -FLT_MAX : FLT_MAX

                                 /* let's select nothing, it might even help */
   ;  if (!(heap =  mcxAlloc ((k+have_even)*sizeof(pval), RETURN_ON_FAIL)))
      return mode == KBAR_SELECT_LARGE ? FLT_MAX : -FLT_MAX

   ;  if (mode == KBAR_SELECT_LARGE)
      {  if (have_even)
         *(heap+k) =  PVAL_MAX

      ;  while(vecivp < vecmaxivp)
         {  pval val =  vecivp->val

         ;  if (val >= ignore)
            NOTHING
         ;  else if (n_inserted < k)
            {  dim d =  n_inserted

            ;  while (d != 0 && *(heap+(d-1)/2) > val)
               { *(heap+d) =  *(heap+(d-1)/2)
               ;  d = (d-1)/2
            ;  }
               *(heap+d) =  val
            ;  n_inserted++
         ;  }
            else if (val > *heap)
            {  dim root  =  0
            ;  dim d

            ;  while((d = 2*root+1) < k)
               {  if (*(heap+d) > *(heap+d+1))
                  d++
               ;  if (val > *(heap+d))
                  {  *(heap+root) = *(heap+d)
                  ;  root = d
               ;  }
                  else break
            ;  }
               *(heap+root) = val
         ;  }
            vecivp++
      ;  }
      }

      else if (mode == KBAR_SELECT_SMALL)
      {  if (have_even)
         *(heap+k) = -PVAL_MAX

      ;  while(vecivp < vecmaxivp)
         {  pval val = vecivp->val

         ;  if (val < ignore)
            NOTHING
         ;  else if (n_inserted < k)
            {  dim d = n_inserted

            ;  while (d != 0 && *(heap+(d-1)/2) < val)
               { *(heap+d) = *(heap+(d-1)/2)
               ;  d = (d-1)/2
            ;  }
               *(heap+d) = val
            ;  n_inserted++
         ;  }
            else if (val < *heap)
            {  dim root = 0
            ;  dim d

            ;  while((d = 2*root+1) < k)
               {  if (*(heap+d) < *(heap+d+1))
                  d++
               ;  if (val < *(heap+d))
                  {  *(heap+root) = *(heap+d)
                  ;  root = d
               ;  }
                  else break
            ;  }
               *(heap+root) = val
         ;  }
            vecivp++
      ;  }
      }
      else
      {  mcxErr("mclvKBar PBD", "invalid mode")
      ;  mcxExit(1)
   ;  }

      ans = *heap
   ;  mcxFree(heap)
   ;  return ans
;  }
Пример #26
0
int main
(  int                  argc
   ,  const char*          argv[]
)
{   mcxIO *xf_cl = NULL, *xf_mx = NULL
                                  ;
    mclx *cl = NULL, *elcl = NULL
                             ;
    int a = 1
            ;
    dim i

    ;
    mcxLogLevel =
        MCX_LOG_AGGR | MCX_LOG_MODULE | MCX_LOG_IO | MCX_LOG_GAUGE | MCX_LOG_WARN
        ;
    mclxIOsetQMode("MCLXIOVERBOSITY", MCL_APP_VB_YES)
    ;
    mclx_app_init(stderr)

    ;
    while(a < argc)
    {   if (!strcmp(argv[a], "-icl"))
        {   if (a++ + 1 < argc)
                xf_cl =  mcxIOnew(argv[a], "r")
                         ;
            else goto arg_missing
                ;
        }
        else if (!strcmp(argv[a], "-h"))
        {   help
:
            mcxUsage(stdout, me, usagelines)
            ;
            mcxExit(STATUS_FAIL)
            ;
        }
        else if (!strcmp(argv[a], "--version"))
        {   app_report_version(me)
            ;
            exit(0)
            ;
        }
        else if (!strcmp(argv[a], "-imx"))
        {   if (a++ + 1 < argc)
                xf_mx = mcxIOnew(argv[a], "r")
                        ;
            else goto arg_missing
                ;
        }
        else if (!strcmp(argv[a], "-h"))
        {   goto help
            ;
        }
        else if (0)
        {   arg_missing:
            ;
            mcxErr
            (  me
               ,  "flag <%s> needs argument; see help (-h)"
               ,  argv[argc-1]
            )
            ;
            mcxExit(1)
            ;
        }
        else
        {   mcxErr
            (  me
               ,  "unrecognized flag <%s>; see help (-h)"
               ,  argv[a]
            )
            ;
            mcxExit(1)
            ;
        }
        a++
        ;
    }

    if (!xf_cl)
        mcxErr(me, "need cluster file")
        ,  mcxExit(1)

        ;
    cl =  mclxRead(xf_cl, EXIT_ON_FAIL)
          ;
    elcl = mclxTranspose(cl)

           ;
    for (i=0; i<N_COLS(elcl); i++)
    {   mclv* vec = elcl->cols+i
                    ;
        if (vec->n_ivps > 1)
            fprintf(stdout, "%ld\n", (long) vec->vid)
            ;
    }

    return 0
           ;
}