Method run

src/modules/convex/lmf_igd.cpp:40–111

* @brief Perform the low-rank matrix factorization transition step * * Called for each tuple. */

 * Called for each tuple.
 */
AnyType
lmf_igd_transition::run(AnyType &args) {
    // The real state.
    // For the first tuple: args[0] is nothing more than a marker that
    // indicates that we should do some initial operations.
    // For other tuples: args[0] holds the computation state until last tuple
    LMFIGDState<MutableArrayHandle<double> > state = args[0];

    // initilize the state if first tuple
    if (state.algo.numRows == 0) {
        if (!args[4].isNull()) {
            LMFIGDState<ArrayHandle<double> > previousState = args[4];
            state.allocate(*this, previousState.task.rowDim,
                    previousState.task.colDim, previousState.task.maxRank);
            state = previousState;
        } else {
            // configuration parameters
            int32_t rowDim = args[5].getAs<int32_t>();
            if (rowDim <= 0) {
                throw std::runtime_error("Invalid parameter: row_dim <= 0");
            }
            int32_t columnDim = args[6].getAs<int32_t>();
            if (columnDim <= 0) {
                throw std::runtime_error("Invalid parameter: column_dim <= 0");
            }
            int32_t maxRank = args[7].getAs<int32_t>();
            if (maxRank <= 0) {
                throw std::runtime_error("Invalid parameter: max_rank <= 0");
            }
            if (maxRank >= rowDim || maxRank >= columnDim) {
                throw std::runtime_error("Invalid parameter: "
                        "max_rank >= row_dim || max_rank >= column_dim");
            }
            double stepsize = args[8].getAs<double>();
            if (stepsize <= 0.) {
                throw std::runtime_error("Invalid parameter: stepsize <= 0.0");
            }
            double scaleFactor = args[9].getAs<double>();
            if (scaleFactor <= 0.) {
                throw std::runtime_error("Invalid parameter: "
                        "scale_factor <= 0.0");
            }

            state.allocate(*this, rowDim, columnDim, maxRank);
            state.task.stepsize = stepsize;
            state.task.scaleFactor = scaleFactor;
            state.task.model.initialize(scaleFactor);
        }
        // resetting in either case
        state.reset();
    }

    // tuple
    LMFTuple tuple;
    tuple.indVar.i = args[1].getAs<int32_t>();
    tuple.indVar.j = args[2].getAs<int32_t>();
    if (tuple.indVar.i == 0 || tuple.indVar.j == 0) {
        throw std::runtime_error("Invalid parameter: [col_row] = 0 or "