update

snoweye · snoweye · commit f49800fea674 · 2013-06-22T14:39:23.000-04:00
diff --git a/NAMESPACE b/NAMESPACE
@@ -11,6 +11,7 @@ export(
   "pkmeans",
   "as.dmat",
   "as.spmd",
+  "as.gbd",
 
   ### Example functions in SPMD.
   "generate.basic",
diff --git a/R/00_pmclust_internal.r b/R/00_pmclust_internal.r
@@ -15,7 +15,7 @@ pmclust.internal <- function(X = NULL, K = 2, MU = NULL,
   # Check X.
   if(is.null(X)){
     if(exists("X.dmat", envir = .GlobalEnv)){
-      # Assign X to .pmclustEnv and convert to spmdr.
+      # Assign X to .pmclustEnv and convert to gbdr.
       convert.data(.GlobalEnv$X.dmat, method.own.X[1], rank.own.X, comm)
     } else{
       # Assume X.spmd in .GlobalEnv and no need for converting or check.
diff --git a/R/01_as_dmat.r b/R/01_as_dmat.r
@@ -1,15 +1,15 @@
-### Convert X.spmd to X.dmat
+### Convert X.gbd to X.dmat
 
-as.dmat <- function(X.spmd, bldim = .BLDIM, ICTXT = .ICTXT,
+as.dmat <- function(X.gbd, bldim = .BLDIM, ICTXT = .ICTXT,
     comm = .SPMD.CT$comm){
-  X.spmd <- load.balance(X.spmd, comm = comm)
+  X.gbd <- load.balance(X.gbd, comm = comm)
 
-  N.spmd <- nrow(X.spmd)
-  p <- ncol(X.spmd)
-  N <- spmd.allreduce.integer(N.spmd, integer(1), op = "sum")
+  N.gbd <- nrow(X.gbd)
+  p <- ncol(X.gbd)
+  N <- spmd.allreduce.integer(N.gbd, integer(1), op = "sum")
 
-  X.dmat <- ddmatrix(0, N, p, bldim = c(N.spmd, p), CTXT = 2)
-  X.dmat@Data <- X.spmd
+  X.dmat <- ddmatrix(0, N, p, bldim = c(N.gbd, p), CTXT = 2)
+  X.dmat@Data <- X.gbd
   X.dmat <- redistribute(X.dmat, bldim = bldim, ICTXT = ICTXT)
 
   X.dmat
diff --git a/R/01_as_spmd.r b/R/01_as_spmd.r
@@ -23,3 +23,5 @@ as.spmd <- function(X.dmat, comm = .SPMD.CT$comm){
 
   X.spmd
 } # End of as.spmd().
+
+as.gbd <- as.spmd
diff --git a/R/02_convert_data.r b/R/02_convert_data.r
@@ -9,16 +9,16 @@ convert.data <- function(X, method.own.X = .PMC.CT$method.own.X,
   if(is.ddmatrix(X)){
     # For a ddmatrix.
 
-    .pmclustEnv$X.spmd <- as.spmd(X, comm = comm)
+    .pmclustEnv$X.spmd <- as.gbd(X, comm = comm)
   } else{
-    # for a spmd matrix.
+    # for a GBD matrix.
 
     if(is.null(X)){
       X <- matrix(0, nrow = 0, ncol = 0)
     }
 
-    if(method.own.X[1] == "spmdr"){
-      # For spmd row-major
+    if(method.own.X[1] == "gbdr"){
+      # For GBD row-major
 
       p <- ncol(X)
       p.all <- spmd.allgather.integer(p, integer(COMM.SIZE), comm = comm)
diff --git a/R/02_load_balance.r b/R/02_load_balance.r
@@ -1,20 +1,20 @@
 ### This file contains functions to load balance of data X.spmd.
 
 balance.info <- function(X.spmd, comm = .SPMD.CT$comm,
-    spmd.major = 1, method = c("block.cyclic", "block0")){
+    gbd.major = 1, method = c("block.cyclic", "block0")){
   COMM.SIZE <- spmd.comm.size(comm)
   COMM.RANK <- spmd.comm.rank(comm)
 
   if(!is.matrix(X.spmd)){
     X.spmd <- as.matrix(X.spmd)
   }
 
-  if(spmd.major == 1){
+  if(gbd.major == 1){
     N.spmd <- nrow(X.spmd)
-  } else if(spmd.major == 2){
+  } else if(gbd.major == 2){
     N.spmd <- ncol(X.spmd)
   } else{
-    stop("spmd.major = 1 or 2.")
+    stop("gbd.major = 1 or 2.")
   }
   N.allspmd <- spmd.allgather.integer(as.integer(N.spmd), integer(COMM.SIZE),
                                       comm = comm)
@@ -60,31 +60,31 @@ balance.info <- function(X.spmd, comm = .SPMD.CT$comm,
                           belong = rank.belong[rank.belong == COMM.RANK])
 
   list(send = send.info, recv = recv.info, N.allspmd = N.allspmd,
-       new.N.allspmd = new.N.allspmd, spmd.major = spmd.major)
+       new.N.allspmd = new.N.allspmd, gbd.major = gbd.major)
 } # End of balance.info()
 
 
 load.balance <- function(X.spmd, bal.info = NULL, comm = .SPMD.CT$comm,
-    spmd.major = 1){
+    gbd.major = 1){
   COMM.RANK <- spmd.comm.rank(comm)
   if(is.null(bal.info)){
-    bal.info <- balance.info(X.spmd, comm = comm, spmd.major = spmd.major)
+    bal.info <- balance.info(X.spmd, comm = comm, gbd.major = gbd.major)
   }
 
   if(!is.matrix(X.spmd)){
     X.spmd <- as.matrix(X.spmd)
   }
-  if(spmd.major == 1){
+  if(gbd.major == 1){
     p <- ncol(X.spmd)
-  } else if(spmd.major == 2){
+  } else if(gbd.major == 2){
     p <- nrow(X.spmd)
   } else{
-    stop("spmd.major = 1 or 2.")
+    stop("gbd.major = 1 or 2.")
   }
 
   send.to <- as.integer(unique(bal.info$send$belong))
   if(length(send.to) > 0){
-    if(spmd.major == 1){
+    if(gbd.major == 1){
       for(i in send.to){
         if(i != COMM.RANK){
           tmp <- matrix(X.spmd[bal.info$send$belong == i,], ncol = p)
@@ -104,7 +104,7 @@ load.balance <- function(X.spmd, bal.info = NULL, comm = .SPMD.CT$comm,
   recv.from <- as.integer(unique(bal.info$recv$org))
   if(length(recv.from) > 0){
     ret <- NULL
-    if(spmd.major == 1){
+    if(gbd.major == 1){
       for(i in recv.from){
         if(i != COMM.RANK){
           tmp <- recv(rank.source = i, tag = i, comm = comm)
@@ -130,7 +130,7 @@ load.balance <- function(X.spmd, bal.info = NULL, comm = .SPMD.CT$comm,
   }
 
   if(bal.info$new.N.allspmd[spmd.comm.rank(comm) + 1] == 0){
-    if(spmd.major == 1){
+    if(gbd.major == 1){
       ret <- matrix(0, nrow = 0, ncol = p)
     } else{
       ret <- matrix(0, nrow = p, ncol = 0)
@@ -148,7 +148,7 @@ unload.balance <- function(new.X.spmd, bal.info, comm = .SPMD.CT$comm){
                                          belong = bal.info$send$org),
                        N.allspmd = bal.info$new.N.allspmd,
                        new.N.allspmd = bal.info$N.allspmd,
-                       spmd.major = bal.info$spmd.major)
+                       gbd.major = bal.info$gbd.major)
   load.balance(new.X.spmd, bal.info = rev.bal.info, comm = comm)
 } # End of unload.balance().
 
diff --git a/data/control.r b/data/control.r
@@ -5,7 +5,7 @@
                 "em.dmat", "kmeans.dmat"),
   algorithm.spmd = c("em", "aecm", "apecm", "apecma", "kmeans"),
   algorithm.dmat = c("em.dmat", "kmeans.dmat"),
-  method.own.X = c("spmdr", "common", "single", "ddmatrix"),
+  method.own.X = c("gbdr", "common", "single", "ddmatrix"),
   CONTROL = list(
               max.iter = 1000,
               abs.err = 1e-4,
diff --git a/demo/00Index b/demo/00Index
@@ -6,7 +6,7 @@ ex_kmeans	pmclust		An example of K-means algorithm.
 ex_MixSim	pmclust		An example of utilizing MixSim.
 dmat_em		pmclust		A ddmatrix example of EM algorithm.
 dmat_kmeans	pmclust		A ddmatrix example of K-means algorithm.
-iris_spmdr	pmclust		iris example in SPMD row-major format.
+iris_gbdr	pmclust		iris example in GBD row-major format.
 iris_common	pmclust		iris example in common on all processors.
 iris_single	pmclust		iris example in a single processor.
 iris_dmat	pmclust		iris example in ddmatrix.
diff --git a/demo/ex_MixSim.r b/demo/ex_MixSim.r
@@ -11,7 +11,7 @@ X.spmd <- data.spmd$X.spmd
 
 ### Run clustering.
 PARAM.org <- set.global(K = K)          # Set global storages.
- PARAM.org <- initial.em(PARAM.org)    # One initial.
+ PARAM.org <- initial.em(PARAM.org)      # One initial.
 # PARAM.org <- initial.RndEM(PARAM.org)   # Ten initials by default.
 PARAM.new <- apecma.step(PARAM.org)     # Run APECMa.
 em.update.class()                       # Get classification.
diff --git a/demo/iris_gbdr.r b/demo/iris_gbdr.r
diff --git a/inst/doc/pmclust-guide.pdf b/inst/doc/pmclust-guide.pdf
diff --git a/inst/doc/pmclust-include/01-introduction.tex b/inst/doc/pmclust-include/01-introduction.tex
@@ -72,7 +72,7 @@
 in different data distributed format to demonstrate several algorithms
 including parallel model-based clustering and parallel K-means.
 \begin{Command}
-mpiexec -np 2 Rscript -e "demo(iris_spmdr,'pmclust',ask=F,echo=F)"
+mpiexec -np 2 Rscript -e "demo(iris_gbdr,'pmclust',ask=F,echo=F)"
 mpiexec -np 2 Rscript -e "demo(iris_common,'pmclust',ask=F,echo=F)"
 mpiexec -np 2 Rscript -e "demo(iris_single,'pmclust',ask=F,echo=F)"
 mpiexec -np 2 Rscript -e "demo(iris_dmat,'pmclust',ask=F,echo=F)"
@@ -83,11 +83,11 @@
 
 Each of these commands will run \code{pmclust()} and \code{pkmeans()} on
 a matrix \code{X.std} in four formats.
-\code{spmdr} is SPMD row-major format,
+\code{gbdr} is GBD row-major format,
 \code{common} assumes \code{X.std} commonly exists on all processors,
 \code{single} assumes \code{X.std} only exists on rank 0 by default, and
 \code{dmat} assumes \code{X.std} is a \code{ddmatrix}.
 See \pkg{pbdDEMO}~\citep{Schmidt2013pbdDEMOpackage} and it's
 vignette~\citep{Schmidt2013pbdDEMOvignette}
-for more details of \code{spmdr} and \code{ddmatrix}.
+for more details of \code{gbdr} and \code{ddmatrix}.
 
diff --git a/inst/doc/pmclust-include/02-example.tex b/inst/doc/pmclust-include/02-example.tex
@@ -209,7 +209,7 @@
 \caption{The functions for \code{ddmatrix}}
 \label{tab:dmat}
 \begin{tabular}{lll} \hline \hline
-\code{ddmatrix}  & SPMD        & Algorithm \\ \hline
+\code{ddmatrix}  & GBD         & Algorithm \\ \hline
 em.step.dmat     & em.step     & EM        \\
 (TBD)            & aecm.step   & AECM      \\
 (TBD)            & apecm.step  & APECM     \\
diff --git a/man/13_d.control.Rd b/man/13_d.control.Rd
@@ -37,7 +37,7 @@
 
   Currently, the \code{algorithm} could be
   \code{em}, \code{aecm}, \code{apecm}, \code{apecma}, and \code{kmeans}
-  for SPMD and ddmatrix (with \code{*.dmat}).
+  for GBD and ddmatrix (with \code{*.dmat}).
   The \code{method.own.X} could be \code{spmdr}, \code{common}, \code{single},
   and \code{ddmatrix}.
 }
diff --git a/man/30-em.one.Rd b/man/30-em.one.Rd
@@ -1,7 +1,7 @@
 \name{One Step of EM algorithm}
 \alias{em.onestep}
 \alias{em.onestep.dmat}
-\title{One EM Step for SPMD}
+\title{One EM Step for GBD}
 \description{
   One EM step only for model-based clustering of finite mixture Gaussian
   models with unstructured dispersions.
diff --git a/man/30-em_like.Rd b/man/30-em_like.Rd
@@ -6,7 +6,7 @@
 \alias{kmeans.step}
 \alias{em.step.dmat}
 \alias{kmeans.step.dmat}
-\title{EM-like Steps for SPMD}
+\title{EM-like Steps for GBD}
 \description{
   The EM-like algorithm for model-based clustering of finite mixture Gaussian
   models with unstructured dispersions.
diff --git a/man/50-as.dmat.gbd.Rd b/man/50-as.dmat.gbd.Rd
@@ -1,27 +1,28 @@
 \name{as functions}
 \alias{as.dmat}
-\alias{as.spmd}
-\title{Convert between X.spmd and X.dmat}
+\alias{as.gbd}
+\title{Convert between X.gbd and X.dmat}
 \description{
   This function will convert a matrix of format from
   SPDM row-major to ddmatrix vice versa.
 }
 \usage{
-  as.dmat(X.spmd, bldim = .BLDIM, ICTXT = .ICTXT, comm = .SPMD.CT$comm)
-
+  as.dmat(X.gbd, bldim = .BLDIM, ICTXT = .ICTXT, comm = .SPMD.CT$comm)
   as.spmd(X.dmat, comm = .SPMD.CT$comm)
+
+  as.gbd(X.dmat, comm = .SPMD.CT$comm)
 }
 \arguments{
-  \item{X.spmd}{an input dataset of format SPMD row-major to be converted.}
+  \item{X.gbd}{an input dataset of format GBD row-major to be converted.}
   \item{X.dmat}{an input dataset of format \code{ddmatrix} to be converted.}
   \item{bldim}{block dimension, see \pkg{pbdBASE} and \pkg{pbdDMAT} for details.}
   \item{ICTXT}{block context, see \pkg{pbdBASE} and \pkg{pbdDMAT} for details.}
   \item{comm}{communicator, see \pkg{pbdMPI} for details.}
 }
 \details{
-  This function will provide a quick conversion to the input data \code{X.spmd}
+  This function will provide a quick conversion to the input data \code{X.gbd}
   which is a default dataset to be clustered in \pkg{pmclust}. Usually, this
-  matrix is distributed in SPMD row-major format. For fully utilizing
+  matrix is distributed in GBD row-major format. For fully utilizing
   \pkg{pbdBASE} and \pkg{pbdDMAT}, it need to be converted to \code{ddmatrix}
   format.
 }
