@@ -1,8 +1,8 @@

 # include macros

-m4_builtin([include], ax_check_compile_flag.m4)

-m4_builtin([include], ax_compiler_vendor.m4)

-m4_builtin([include], ax_compiler_version.m4)

-m4_builtin([include], ax_openmp.m4)

+m4_builtin([include], m4/ax_check_compile_flag.m4)

+m4_builtin([include], m4/ax_compiler_vendor.m4)

+m4_builtin([include], m4/ax_compiler_version.m4)

+m4_builtin([include], m4/ax_openmp.m4)

 # get version of CoGAPS from DESCRIPTION file

 AC_INIT(CoGAPS, m4_esyscmd_s([awk -e '/^Version:/ {print $2}' Repo/DESCRIPTION]))

@@ -1,28 +1,56 @@

-#include "GapsRunner.h"

-#include "file_parser/MtxParser.h"

+#include "GapsDispatcher.h"

 #include "math/SIMD.h"

 #include <Rcpp.h>

+template <class T>

+static Rcpp::List cogapsRun(T data, unsigned nPatterns,

+unsigned maxIter, unsigned outputFrequency, unsigned seed, float alphaA,

+float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool messages,

+bool singleCellRNASeq)

+{

+    GapsDispatcher dispatcher;

+

+    dispatcher.setNumPatterns(nPatterns);

+    dispatcher.setMaxIterations(maxIter);

+    dispatcher.setOutputFrequency(outputFrequency);

+    dispatcher.setSeed(seed);

+    

+    dispatcher.setAlpha(alphaA, alphaP);

+    dispatcher.setMaxGibbsMass(maxGibbsmassA, maxGibbsmassP);

+

+    dispatcher.printMessages(messages);

+    dispatcher.singleCellRNASeq(singleCellRNASeq);

+    

+    dispatcher.loadData(D);

+    dispatcher.useDefaultUncertainty(); 

+

+    return dispatcher.run();

+}

+

 // [[Rcpp::export]]

-Rcpp::List cogaps_cpp(const Rcpp::NumericMatrix &D,

-const Rcpp::NumericMatrix &S, unsigned nFactor, unsigned nEquil,

-unsigned nEquilCool, unsigned nSample, unsigned nOutputs, unsigned nSnapshots,

-float alphaA, float alphaP, float maxGibbmassA, float maxGibbmassP,

-unsigned seed, bool messages, bool singleCellRNASeq, char whichMatrixFixed,

-const Rcpp::NumericMatrix &FP, unsigned checkpointInterval,

-const std::string &cptFile, unsigned pumpThreshold, unsigned nPumpSamples,

-unsigned nCores)

+Rcpp::List cogapsFromFile_cpp(const std::string &D, unsigned nPatterns,

+unsigned maxIter, unsigned outputFrequency, unsigned seed, float alphaA,

+float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool messages,

+bool singleCellRNASeq)

 {

-    // create internal state from parameters and run from there

-    GapsRunner runner(D, S, nFactor, nEquil, nEquilCool, nSample,

-        nOutputs, nSnapshots, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seed,

-        messages, singleCellRNASeq, checkpointInterval, cptFile,

-        whichMatrixFixed, FP, nCores);

-    return runner.run();

+    return cogapsRun(D, nPatterns, maxIter, outputFrequency, seed,

+        alphaA, alphaP, maxGibbsmassA, maxGibbsMassP, messages,

+        singleCellRNASeq);

 }

 // [[Rcpp::export]]

+Rcpp::List cogaps_cpp(const Rcpp::NumericMatrix &D, unsigned nPatterns,

+unsigned maxIter, unsigned outputFrequency, unsigned seed, float alphaA,

+float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool messages,

+bool singleCellRNASeq)

+{

+    return cogapsRun(RowMatrix(D), nPatterns, maxIter, outputFrequency, seed,

+        alphaA, alphaP, maxGibbsmassA, maxGibbsMassP, messages,

+        singleCellRNASeq);

+}

+

+/*

 Rcpp::List cogapsFromCheckpoint_cpp(const Rcpp::NumericMatrix &D,

 const Rcpp::NumericMatrix &S, unsigned nFactor, unsigned nEquil,

 unsigned nSample, const std::string &fileName, const std::string &cptFile)

@@ -30,12 +58,7 @@ unsigned nSample, const std::string &fileName, const std::string &cptFile)

     GapsRunner runner(D, S, nFactor, nEquil, nSample, cptFile);

     return runner.run();

 }

-

-// [[Rcpp::export]]

-void cogapsFromFile_cpp(const std::string &D)

-{

-    // TODO implement

-}

+*/

 // used to convert defined macro values into strings

 #define STR_HELPER(x) #x

new file mode 100644

@@ -0,0 +1,24 @@

+#include "GapsDispatcher.h"

+

+#include <string>

+

+Rcpp::List GapsDispatcher::run()

+{

+    for (unsigned i = 0; i < mMaxIterations; ++i)

+    {

+        // run all GapsRunners for K iterations

+

+        // sync P matrices

+

+        // broadcast master P and weight

+    }

+

+    // sync all P matrices to same master

+

+    for (unsigned i = 0; i < mMaxIterations; ++i)

+    {

+        // runner all samplers with sampling turned on

+    }

+

+    // stitch together matrices

+}

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,77 @@

+#ifndef __COGAPS_DISPATCHER_H__

+#define __COGAPS_DISPATCHER_H__

+

+#include "GapsRunner.h"

+

+#include <string>

+

+struct GapsReturn

+{

+    ColMatrix Amean;

+    ColMatrix Asd;

+    RowMatrix Pmean;

+    RowMatrix Psd;

+    

+    float meanChiSq;

+    uint32_t seed;

+};

+

+// should be agnostic to external caller (R/Python/CLI)

+class GapsDispatcher

+{

+private:

+

+    unsigned mNumPatterns;

+    unsigned mMaxIterations;

+    unsigned mOutputFrequency;

+    uint32_t mSeed;

+

+    float mAlphaA;

+    float mAlphaP;

+    float mMaxGibbsMassA;

+    float mMaxGibbsMassP;

+

+    bool mPrintMessages;

+    bool mSingleCellRnaSeq;

+

+    std:vector<GapsRunner*> mRunners;

+

+public:

+

+    GapsDispatcher() : mNumPatterns(3), mMaxIterations(1000),

+        mOutputFrequency(250), mSeed(0), mAlphaA(0.01), mAlphaP(0.01),

+        mMaxGibbsMassA(100.f), mMaxGibbsMassP(100.f), mPrintMessages(true),

+        mSingleCellRnaSeq(false)

+    {}

+

+    void setNumPatterns(unsigned n)     { mNumPatterns = n; }

+    void setMaxIterations(unsigned n)   { mMaxIterations = n; }

+    void setOutputFrequency(unsigned n) { mOutputFrequency = n; }

+    void setSeed(unsigned seed)         { mSeed = seed; }

+

+    void printMessages(bool print) { mPrintMessages = print; }

+    void singleCellRNASeq(bool sc) { mSingleCellRnaSeq = sc; }

+

+    void setAlpha(float alphaA, float alphaP)

+    {

+        mAlphaA = alphaA;

+        mAlphaP = alphaP;

+    }

+

+    void setMaxGibbsMass(float maxA, float maxP)

+    {

+        mMaxGibbsMassA = maxA;

+        mMaxGibbsMassP = maxP;

+    }

+

+    void useDefaultUncertainty();

+    void setUncertainty(const std::string &pathToMatrix);

+    void setUncertainty(const RowMatrix &S);

+

+    void loadData(const RowMatrix &D);

+    void loadData(const std::string &pathToData);    

+    

+    Rcpp::List run();

+};

+

+#endif

\ No newline at end of file

@@ -81,7 +81,10 @@ public:

 public:

-    // construct from parameters

+    // construct from file name

+    GapsRunner();

+

+    // construct from R object

     GapsRunner(const Rcpp::NumericMatrix &D, const Rcpp::NumericMatrix &S,

         unsigned nFactor, unsigned nEquil, unsigned nCool, unsigned nSample,

         unsigned nOutputs, unsigned nSnapshots, float alphaA, float alphaP,

@@ -94,8 +97,22 @@ public:

         unsigned nFactor, unsigned nEquil, unsigned nSample,

         const std::string &cptFile);

-    // run all phases of algorithm

-    Rcpp::List run();

+    void run();

+    void halt();

+

+    void startSampling();

+

+    ColMatrix getAMatrix();

+    RowMatrix getPMatrix();

+

+    ColMatrix

+

+    void setPMatrix(const RowMatrix &Pmaster, float weight);

+

+    ColMatrix AMean() const;

+    ColMatrix AStd() const;

+    RowMatrix PMean() const;

+    RowMatrix PStd() const;

 };

 #endif // __COGAPS_GAPS_RUNNER_H__

\ No newline at end of file

@@ -4,6 +4,7 @@ PKG_LIBS = @GAPS_LIBS@

 OBJECTS =   AtomicDomain.o \

             Cogaps.o \

+            GapsDispatcher.o \

             GapsRunner.o \

             GapsStatistics.o \

             GibbsSampler.o \