Let MEX interface return algorithm information

Author: mfasi

mex/gemmi.cpp

@@ -19,9 +19,9 @@ class MexFunction : public matlab::mex::Function {
         }
 
         // Validate input.
-        validateInput(inputs);
+        validateInput(inputs, outputs);
 
-       size_t numSplitsA = std::move(inputs[2][0]);
+        size_t numSplitsA = std::move(inputs[2][0]);
         size_t numSplitsB = inputs.size() == 3 ? numSplitsA : std::move(inputs[3][0]);
 
         if (inputs[0].getType() == matlab::data::ArrayType::DOUBLE &&
@@ -40,6 +40,14 @@ class MexFunction : public matlab::mex::Function {
             matlabPtr->feval(u"error",
                 0, std::vector<matlab::data::Array>({ factory.createScalar("Unsupported combination of data type.") }));
         }
+
+        if (outputs.size() == 2) {
+            matlab::data::ArrayFactory factory;
+            matlab::data::StructArray S = factory.createStructArray({1, 1}, {"split", "acc"});
+            S[0]["split"] = factory.createCharArray(options->splitType == splittingStrategy::roundToNearest ? "n" : "b");
+            S[0]["acc"] = factory.createCharArray(options->accType == accumulationStrategy::floatingPoint ? "f" : "i");
+            outputs[1] = std::move(S);
+        }
     }
 
 private:
@@ -73,10 +81,15 @@ class MexFunction : public matlab::mex::Function {
         return factory.createArray({A_size[0], B_size[1]}, C.begin(), C.end());;
     }
 
-    void validateInput(matlab::mex::ArgumentList inputs) {
+    void validateInput(matlab::mex::ArgumentList inputs, matlab::mex::ArgumentList outputs) {
         std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine();
         matlab::data::ArrayFactory factory;
 
+        if (outputs.size() < 1 || outputs.size() > 2) {
+            matlabPtr->feval(u"error",
+                0, std::vector<matlab::data::Array>({ factory.createScalar("This function requires one or two output arguments.") }));
+        }
+
         size_t numArgs = inputs.size();
 
         if ( numArgs < 3 || numArgs > 5) {

mex/gemmi.m

@@ -1,20 +1,22 @@
 %  GEMMI    Compute matrix product using integer Ozaki scheme.
-%   C = GEMMI(A,B,ASPLITS,BSPLITS,ALGORITHM) computes the product A*B
-%   using the Ozaki scheme with ASPLITS and BSPLITS slices for the
-%   matrices A and B, respectively. The ALGORITHM parameter must be
-%   a struct, with the following fields currently supported.
+%   [C, ALGOUT] = GEMMI(A,B,ASPLITS,BSPLITS,ALGIN) computes the matrix
+%   C = A*B using the Ozaki scheme with ASPLITS and BSPLITS slices 
+%   for the matrices A and B, respectively. The ALGIN parameter
+%   must be a struct, with the following fields currently supported.
 %   'split' - selects the stragegy to be used to split A and B into
 %             slices. Possible values are 'b' for bitmasking and 'n
-%             for round-to-nearest (default).
+%             for round-to-nearest (default). 
 %   'acc'   - selects how the exact integer matrix products are
 %             accumulated. Possible values are 'f' for floating-point
 %             arithmetic and 'i' for integer accumulation (default).
+%   The output paramater ALGOUT is a struct with the same fields as
+%   ALGIN, which contains the values used in the computation.
 %    
-%   C = GEMMI(A,B,ASPLITS,BSPLITS) uses the last ALGORITHM parameter
-%   in the most recent call to GEMMI, or the default values if no
-%   previous call was made.
+%   [...] = GEMMI(A,B,ASPLITS,BSPLITS) uses the ALGIN parameter passed
+%   the most recent call to GEMMI, or the default values if no previous
+%   call was made.
 %
-%   C = GEMMI(A,B,SPLITS) uses SPLITS slices for both A and B.
+%   [...] = GEMMI(A,B,SPLITS) uses SPLITS slices for both A and B.
 % 
 %   The splits are stored as 8-bit signed integer, the dot products are
 %   performed using 32-bit signed arithmetic, and the final accumulation