libmf 0.1.2 → 0.2.3

data/vendor/libmf/mf.cpp

@@ -1,4683 +0,0 @@
-#include <algorithm>
-#include <cmath>
-#include <condition_variable>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <memory>
-#include <numeric>
-#include <queue>
-#include <random>
-#include <stdexcept>
-#include <string>
-#include <thread>
-#include <unordered_set>
-#include <vector>
-#include <limits>
-
-#include "mf.h"
-
-#if defined USESSE
-#include <pmmintrin.h>
-#endif
-
-#if defined USEAVX
-#include <immintrin.h>
-#endif
-
-#if defined USEOMP
-#include <omp.h>
-#endif
-
-namespace mf
-{
-
-using namespace std;
-
-namespace // unnamed namespace
-{
-
-mf_int const kALIGNByte = 32;
-mf_int const kALIGN = kALIGNByte/sizeof(mf_float);
-
-//--------------------------------------
-//---------Scheduler of Blocks----------
-//--------------------------------------
-
-class Scheduler
-{
-public:
-    Scheduler(mf_int nr_bins, mf_int nr_threads, vector<mf_int> cv_blocks);
-    mf_int get_job();
-    mf_int get_bpr_job(mf_int first_block, bool is_column_oriented);
-    void put_job(mf_int block, mf_double loss, mf_double error);
-    void put_bpr_job(mf_int first_block, mf_int second_block);
-    mf_double get_loss();
-    mf_double get_error();
-    mf_int get_negative(mf_int first_block, mf_int second_block,
-                        mf_int m, mf_int n, bool is_column_oriented);
-    void wait_for_jobs_done();
-    void resume();
-    void terminate();
-    bool is_terminated();
-
-private:
-    mf_int nr_bins;
-    mf_int nr_threads;
-    mf_int nr_done_jobs;
-    mf_int target;
-    mf_int nr_paused_threads;
-    bool terminated;
-    vector<mf_int> counts;
-    vector<mf_int> busy_p_blocks;
-    vector<mf_int> busy_q_blocks;
-    vector<mf_double> block_losses;
-    vector<mf_double> block_errors;
-    vector<minstd_rand0> block_generators;
-    unordered_set<mf_int> cv_blocks;
-    mutex mtx;
-    condition_variable cond_var;
-    default_random_engine generator;
-    uniform_real_distribution<mf_float> distribution;
-    priority_queue<pair<mf_float, mf_int>,
-                   vector<pair<mf_float, mf_int>>,
-                   greater<pair<mf_float, mf_int>>> pq;
-};
-
-Scheduler::Scheduler(mf_int nr_bins, mf_int nr_threads,
-    vector<mf_int> cv_blocks)
-    : nr_bins(nr_bins),
-      nr_threads(nr_threads),
-      nr_done_jobs(0),
-      target(nr_bins*nr_bins),
-      nr_paused_threads(0),
-      terminated(false),
-      counts(nr_bins*nr_bins, 0),
-      busy_p_blocks(nr_bins, 0),
-      busy_q_blocks(nr_bins, 0),
-      block_losses(nr_bins*nr_bins, 0),
-      block_errors(nr_bins*nr_bins, 0),
-      cv_blocks(cv_blocks.begin(), cv_blocks.end()),
-      distribution(0.0, 1.0)
-{
-    for(mf_int i = 0; i < nr_bins*nr_bins; ++i)
-    {
-        if(this->cv_blocks.find(i) == this->cv_blocks.end())
-            pq.emplace(distribution(generator), i);
-        block_generators.push_back(minstd_rand0(rand()));
-    }
-}
-
-mf_int Scheduler::get_job()
-{
-    bool is_found = false;
-    pair<mf_float, mf_int> block;
-
-    while(!is_found)
-    {
-        lock_guard<mutex> lock(mtx);
-        vector<pair<mf_float, mf_int>> locked_blocks;
-        mf_int p_block = 0;
-        mf_int q_block = 0;
-
-        while(!pq.empty())
-        {
-            block = pq.top();
-            pq.pop();
-
-            p_block = block.second/nr_bins;
-            q_block = block.second%nr_bins;
-
-            if(busy_p_blocks[p_block] || busy_q_blocks[q_block])
-                locked_blocks.push_back(block);
-            else
-            {
-                busy_p_blocks[p_block] = 1;
-                busy_q_blocks[q_block] = 1;
-                counts[block.second] += 1;
-                is_found = true;
-                break;
-            }
-        }
-
-        for(auto &block1 : locked_blocks)
-            pq.push(block1);
-    }
-
-    return block.second;
-}
-
-mf_int Scheduler::get_bpr_job(mf_int first_block, bool is_column_oriented)
-{
-    lock_guard<mutex> lock(mtx);
-    mf_int another = first_block;
-    vector<pair<mf_float, mf_int>> locked_blocks;
-
-    while(!pq.empty())
-    {
-        pair<mf_float, mf_int> block = pq.top();
-        pq.pop();
-
-        mf_int p_block = block.second/nr_bins;
-        mf_int q_block = block.second%nr_bins;
-
-        auto is_rejected = [&] ()
-        {
-            if(is_column_oriented)
-                return first_block%nr_bins != q_block ||
-                       busy_p_blocks[p_block];
-            else
-                return first_block/nr_bins != p_block ||
-                         busy_q_blocks[q_block];
-        };
-
-        if(is_rejected())
-            locked_blocks.push_back(block);
-        else
-        {
-            busy_p_blocks[p_block] = 1;
-            busy_q_blocks[q_block] = 1;
-            another = block.second;
-            break;
-        }
-    }
-
-    for(auto &block : locked_blocks)
-        pq.push(block);
-
-    return another;
-}
-
-void Scheduler::put_job(mf_int block_idx, mf_double loss, mf_double error)
-{
-    // Return the held block to the scheduler
-    {
-        lock_guard<mutex> lock(mtx);
-        busy_p_blocks[block_idx/nr_bins] = 0;
-        busy_q_blocks[block_idx%nr_bins] = 0;
-        block_losses[block_idx] = loss;
-        block_errors[block_idx] = error;
-        ++nr_done_jobs;
-        mf_float priority =
-            (mf_float)counts[block_idx]+distribution(generator);
-        pq.emplace(priority, block_idx);
-        ++nr_paused_threads;
-        // Tell others that a block is available again.
-        cond_var.notify_all();
-    }
-
-    // Wait if nr_done_jobs (aka the number of processed blocks) is too many
-    // because we want to print out the training status roughly once all blocks
-    // are processed once. This is the only place that a solver thread should
-    // wait for something.
-    {
-        unique_lock<mutex> lock(mtx);
-        cond_var.wait(lock, [&] {
-            return nr_done_jobs < target;
-        });
-    }
-
-    // Nothing is blocking and this thread is going to take another block
-    {
-        lock_guard<mutex> lock(mtx);
-        --nr_paused_threads;
-    }
-}
-
-void Scheduler::put_bpr_job(mf_int first_block, mf_int second_block)
-{
-    if(first_block == second_block)
-        return;
-
-    lock_guard<mutex> lock(mtx);
-    {
-        busy_p_blocks[second_block/nr_bins] = 0;
-        busy_q_blocks[second_block%nr_bins] = 0;
-        mf_float priority =
-            (mf_float)counts[second_block]+distribution(generator);
-        pq.emplace(priority, second_block);
-    }
-}
-
-mf_double Scheduler::get_loss()
-{
-    lock_guard<mutex> lock(mtx);
-    return accumulate(block_losses.begin(), block_losses.end(), 0.0);
-}
-
-mf_double Scheduler::get_error()
-{
-    lock_guard<mutex> lock(mtx);
-    return accumulate(block_errors.begin(), block_errors.end(), 0.0);
-}
-
-mf_int Scheduler::get_negative(mf_int first_block, mf_int second_block,
-        mf_int m, mf_int n, bool is_column_oriented)
-{
-    mf_int rand_val = (mf_int)block_generators[first_block]();
-
-    auto gen_random = [&] (mf_int block_id)
-    {
-        mf_int v_min, v_max;
-
-        if(is_column_oriented)
-        {
-            mf_int seg_size = (mf_int)ceil((double)m/nr_bins);
-            v_min = min((block_id/nr_bins)*seg_size, m-1);
-            v_max = min(v_min+seg_size, m-1);
-        }
-        else
-        {
-            mf_int seg_size = (mf_int)ceil((double)n/nr_bins);
-            v_min = min((block_id%nr_bins)*seg_size, n-1);
-            v_max = min(v_min+seg_size, n-1);
-        }
-        if(v_max == v_min)
-            return v_min;
-        else
-            return rand_val%(v_max-v_min)+v_min;
-    };
-
-    if(rand_val % 2)
-        return (mf_int)gen_random(first_block);
-    else
-        return (mf_int)gen_random(second_block);
-}
-
-void Scheduler::wait_for_jobs_done()
-{
-    unique_lock<mutex> lock(mtx);
-
-    // The first thing the main thread should wait for is that solver threads
-    // process enough matrix blocks.
-    // [REVIEW] Is it really needed? Solver threads automatically stop if they
-    // process too many blocks, so the next wait should be enough for stopping
-    // the main thread when nr_done_job is not enough.
-    cond_var.wait(lock, [&] {
-        return nr_done_jobs >= target;
-    });
-
-    // Wait for all threads to stop. Once a thread realizes that all threads
-    // have processed enough blocks it should stop. Then, the main thread can
-    // print values safely.
-    cond_var.wait(lock, [&] {
-        return nr_paused_threads == nr_threads;
-    });
-}
-
-void Scheduler::resume()
-{
-    lock_guard<mutex> lock(mtx);
-    target += nr_bins*nr_bins;
-    cond_var.notify_all();
-}
-
-void Scheduler::terminate()
-{
-    lock_guard<mutex> lock(mtx);
-    terminated = true;
-}
-
-bool Scheduler::is_terminated()
-{
-    lock_guard<mutex> lock(mtx);
-    return terminated;
-}
-
-//--------------------------------------
-//------------Block of matrix-----------
-//--------------------------------------
-
-class BlockBase
-{
-public:
-    virtual bool move_next() { return false; };
-    virtual mf_node* get_current() { return nullptr; }
-    virtual void reload() {};
-    virtual void free() {};
-    virtual mf_long get_nnz() { return 0; };
-    virtual ~BlockBase() {};
-};
-
-class Block : public BlockBase
-{
-public:
-    Block() : first(nullptr), last(nullptr), current(nullptr) {};
-    Block(mf_node *first_, mf_node *last_)
-        : first(first_), last(last_), current(nullptr) {};
-    bool move_next() { return ++current != last; }
-    mf_node* get_current() { return current; }
-    void tie_to(mf_node *first_, mf_node *last_);
-    void reload() { current = first-1; };
-    mf_long get_nnz() { return last-first; };
-
-private:
-    mf_node* first;
-    mf_node* last;
-    mf_node* current;
-};
-
-void Block::tie_to(mf_node *first_, mf_node *last_)
-{
-    first = first_;
-    last = last_;
-};
-
-class BlockOnDisk : public BlockBase
-{
-public:
-    BlockOnDisk() : first(0), last(0), current(0),
-                    source_path(""), buffer(0) {};
-    bool move_next() { return ++current < last-first; }
-    mf_node* get_current() { return &buffer[static_cast<size_t>(current)]; }
-    void tie_to(string source_path_, mf_long first_, mf_long last_);
-    void reload();
-    void free() { buffer.resize(0); };
-    mf_long get_nnz() { return last-first; };
-
-private:
-    mf_long first;
-    mf_long last;
-    mf_long current;
-    string source_path;
-    vector<mf_node> buffer;
-};
-
-void BlockOnDisk::tie_to(string source_path_, mf_long first_, mf_long last_)
-{
-    source_path = source_path_;
-    first = first_;
-    last = last_;
-}
-
-void BlockOnDisk::reload()
-{
-    ifstream source(source_path, ifstream::in|ifstream::binary);
-    if(!source)
-        throw runtime_error("can not open "+source_path);
-
-    buffer.resize(static_cast<size_t>(last-first));
-    source.seekg(first*sizeof(mf_node));
-    source.read((char*)buffer.data(), (last-first)*sizeof(mf_node));
-    current = -1;
-}
-
-//--------------------------------------
-//-------------Miscellaneous------------
-//--------------------------------------
-
-struct sort_node_by_p
-{
-    bool operator() (mf_node const &lhs, mf_node const &rhs)
-    {
-        return tie(lhs.u, lhs.v) < tie(rhs.u, rhs.v);
-    }
-};
-
-struct sort_node_by_q
-{
-    bool operator() (mf_node const &lhs, mf_node const &rhs)
-    {
-        return tie(lhs.v, lhs.u) < tie(rhs.v, rhs.u);
-    }
-};
-
-struct deleter
-{
-    void operator() (mf_problem *prob)
-    {
-        delete[] prob->R;
-        delete prob;
-    }
-};
-
-
-class Utility
-{
-public:
-    Utility(mf_int f, mf_int n) : fun(f), nr_threads(n) {};
-    void collect_info(mf_problem &prob, mf_float &avg, mf_float &std_dev);
-    void collect_info_on_disk(string data_path, mf_problem &prob,
-                              mf_float &avg, mf_float &std_dev);
-    void shuffle_problem(mf_problem &prob, vector<mf_int> &p_map,
-                         vector<mf_int> &q_map);
-    vector<mf_node*> grid_problem(mf_problem &prob, mf_int nr_bins,
-                                  vector<mf_int> &omega_p,
-                                  vector<mf_int> &omega_q,
-                                  vector<Block> &blocks);
-    void grid_shuffle_scale_problem_on_disk(mf_int m, mf_int n, mf_int nr_bins,
-                                            mf_float scale, string data_path,
-                                            vector<mf_int> &p_map,
-                                            vector<mf_int> &q_map,
-                                            vector<mf_int> &omega_p,
-                                            vector<mf_int> &omega_q,
-                                            vector<BlockOnDisk> &blocks);
-    void scale_problem(mf_problem &prob, mf_float scale);
-    mf_double calc_reg1(mf_model &model, mf_float lambda_p, mf_float lambda_q,
-                        vector<mf_int> &omega_p, vector<mf_int> &omega_q);
-    mf_double calc_reg2(mf_model &model, mf_float lambda_p, mf_float lambda_q,
-                        vector<mf_int> &omega_p, vector<mf_int> &omega_q);
-    string get_error_legend() const;
-    mf_double calc_error(vector<BlockBase*> &blocks,
-                         vector<mf_int> &cv_block_ids,
-                         mf_model const &model);
-    void scale_model(mf_model &model, mf_float scale);
-
-    static mf_problem* copy_problem(mf_problem const *prob, bool copy_data);
-    static vector<mf_int> gen_random_map(mf_int size);
-    // A function used to allocate all aligned float array.
-    // It hides platform-specific function calls. Memory
-    // allocated by malloc_aligned_float must be freed by using
-    // free_aligned_float.
-    static mf_float* malloc_aligned_float(mf_long size);
-    // A function used to free all aligned float array.
-    // It hides platform-specific function calls.
-    static void free_aligned_float(mf_float* ptr);
-    // Initialization function for stochastic gradient method.
-    // Factor matrices P and Q are both randomly initialized.
-    static mf_model* init_model(mf_int loss, mf_int m, mf_int n,
-                                mf_int k, mf_float avg,
-                                vector<mf_int> &omega_p,
-                                vector<mf_int> &omega_q);
-    // Initialization function for one-class CD.
-    // It does zero-initialization on factor matrix P and random initialization
-    // on factor matrix Q.
-    static mf_model* init_model(mf_int m, mf_int n, mf_int k);
-    static mf_float inner_product(mf_float *p, mf_float *q, mf_int k);
-    static vector<mf_int> gen_inv_map(vector<mf_int> &map);
-    static void shrink_model(mf_model &model, mf_int k_new);
-    static void shuffle_model(mf_model &model,
-                              vector<mf_int> &p_map,
-                              vector<mf_int> &q_map);
-    mf_int get_thread_number() const { return nr_threads; };
-private:
-    mf_int fun;
-    mf_int nr_threads;
-};
-
-void Utility::collect_info(
-    mf_problem &prob,
-    mf_float &avg,
-    mf_float &std_dev)
-{
-    mf_double ex = 0;
-    mf_double ex2 = 0;
-
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:ex,ex2)
-#endif
-    for(mf_long i = 0; i < prob.nnz; ++i)
-    {
-        mf_node &N = prob.R[i];
-        ex += (mf_double)N.r;
-        ex2 += (mf_double)N.r*N.r;
-    }
-
-    ex /= (mf_double)prob.nnz;
-    ex2 /= (mf_double)prob.nnz;
-    avg = (mf_float)ex;
-    std_dev = (mf_float)sqrt(ex2-ex*ex);
-}
-
-void Utility::collect_info_on_disk(
-    string data_path,
-    mf_problem &prob,
-    mf_float &avg,
-    mf_float &std_dev)
-{
-    mf_double ex = 0;
-    mf_double ex2 = 0;
-
-    ifstream source(data_path);
-    if(!source.is_open())
-        throw runtime_error("cannot open " + data_path);
-
-    for(mf_node N; source >> N.u >> N.v >> N.r;)
-    {
-        if(N.u+1 > prob.m)
-            prob.m = N.u+1;
-        if(N.v+1 > prob.n)
-            prob.n = N.v+1;
-        prob.nnz += 1;
-        ex += (mf_double)N.r;
-        ex2 += (mf_double)N.r*N.r;
-    }
-    source.close();
-
-    ex /= (mf_double)prob.nnz;
-    ex2 /= (mf_double)prob.nnz;
-    avg = (mf_float)ex;
-    std_dev = (mf_float)sqrt(ex2-ex*ex);
-}
-
-void Utility::scale_problem(mf_problem &prob, mf_float scale)
-{
-    if(scale == 1.0)
-        return;
-
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static)
-#endif
-    for(mf_long i = 0; i < prob.nnz; ++i)
-        prob.R[i].r *= scale;
-}
-
-void Utility::scale_model(mf_model &model, mf_float scale)
-{
-    if(scale == 1.0)
-        return;
-
-    mf_int k = model.k;
-
-    model.b *= scale;
-
-    auto scale1 = [&] (mf_float *ptr, mf_int size, mf_float factor_scale)
-    {
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static)
-#endif
-        for(mf_int i = 0; i < size; ++i)
-        {
-            mf_float *ptr1 = ptr+(mf_long)i*model.k;
-            for(mf_int d = 0; d < k; ++d)
-                ptr1[d] *= factor_scale;
-        }
-    };
-
-    scale1(model.P, model.m, sqrt(scale));
-    scale1(model.Q, model.n, sqrt(scale));
-}
-
-mf_float Utility::inner_product(mf_float *p, mf_float *q, mf_int k)
-{
-#if defined USESSE
-    __m128 XMM = _mm_setzero_ps();
-    for(mf_int d = 0; d < k; d += 4)
-        XMM = _mm_add_ps(XMM, _mm_mul_ps(
-                  _mm_load_ps(p+d), _mm_load_ps(q+d)));
-    __m128 XMMtmp = _mm_add_ps(XMM, _mm_movehl_ps(XMM, XMM));
-    XMM = _mm_add_ps(XMM, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    mf_float product;
-    _mm_store_ss(&product, XMM);
-    return product;
-#elif defined USEAVX
-    __m256 XMM = _mm256_setzero_ps();
-    for(mf_int d = 0; d < k; d += 8)
-        XMM = _mm256_add_ps(XMM, _mm256_mul_ps(
-                  _mm256_load_ps(p+d), _mm256_load_ps(q+d)));
-    XMM = _mm256_add_ps(XMM, _mm256_permute2f128_ps(XMM, XMM, 1));
-    XMM = _mm256_hadd_ps(XMM, XMM);
-    XMM = _mm256_hadd_ps(XMM, XMM);
-    mf_float product;
-    _mm_store_ss(&product, _mm256_castps256_ps128(XMM));
-    return product;
-#else
-    return std::inner_product(p, p+k, q, (mf_float)0.0);
-#endif
-}
-
-mf_double Utility::calc_reg1(mf_model &model,
-                             mf_float lambda_p, mf_float lambda_q,
-                             vector<mf_int> &omega_p, vector<mf_int> &omega_q)
-{
-    auto calc_reg1_core = [&] (mf_float *ptr, mf_int size,
-                               vector<mf_int> &omega)
-    {
-        mf_double reg = 0;
-        for(mf_int i = 0; i < size; ++i)
-        {
-            if(omega[i] <= 0)
-                continue;
-
-            mf_float tmp = 0;
-            for(mf_int j = 0; j < model.k; ++j)
-                tmp += abs(ptr[(mf_long)i*model.k+j]);
-            reg += omega[i]*tmp;
-        }
-        return reg;
-    };
-
-    return lambda_p*calc_reg1_core(model.P, model.m, omega_p)+
-           lambda_q*calc_reg1_core(model.Q, model.n, omega_q);
-}
-
-mf_double Utility::calc_reg2(mf_model &model,
-                             mf_float lambda_p, mf_float lambda_q,
-                             vector<mf_int> &omega_p, vector<mf_int> &omega_q)
-{
-    auto calc_reg2_core = [&] (mf_float *ptr, mf_int size,
-                               vector<mf_int> &omega)
-    {
-        mf_double reg = 0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:reg)
-#endif
-        for(mf_int i = 0; i < size; ++i)
-        {
-            if(omega[i] <= 0)
-                continue;
-
-            mf_float *ptr1 = ptr+(mf_long)i*model.k;
-            reg += omega[i]*Utility::inner_product(ptr1, ptr1, model.k);
-        }
-
-        return reg;
-    };
-
-    return lambda_p*calc_reg2_core(model.P, model.m, omega_p) +
-           lambda_q*calc_reg2_core(model.Q, model.n, omega_q);
-}
-
-mf_double Utility::calc_error(
-    vector<BlockBase*> &blocks,
-    vector<mf_int> &cv_block_ids,
-    mf_model const &model)
-{
-    mf_double error = 0;
-    if(fun == P_L2_MFR || fun == P_L1_MFR || fun == P_KL_MFR ||
-       fun == P_LR_MFC || fun == P_L2_MFC || fun == P_L1_MFC)
-    {
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:error)
-#endif
-        for(mf_int i = 0; i < (mf_long)cv_block_ids.size(); ++i)
-        {
-            BlockBase *block = blocks[cv_block_ids[i]];
-            block->reload();
-            while(block->move_next())
-            {
-                mf_node const &N = *(block->get_current());
-                mf_float z = mf_predict(&model, N.u, N.v);
-                switch(fun)
-                {
-                    case P_L2_MFR:
-                        error += pow(N.r-z, 2);
-                        break;
-                    case P_L1_MFR:
-                        error += abs(N.r-z);
-                        break;
-                    case P_KL_MFR:
-                        error += N.r*log(N.r/z)-N.r+z;
-                        break;
-                    case P_LR_MFC:
-                        if(N.r > 0)
-                            error += log(1.0+exp(-z));
-                        else
-                            error += log(1.0+exp(z));
-                        break;
-                    case P_L2_MFC:
-                    case P_L1_MFC:
-                        if(N.r > 0)
-                            error += z > 0? 1: 0;
-                        else
-                            error += z < 0? 1: 0;
-                        break;
-                    default:
-                        throw invalid_argument("unknown error function");
-                        break;
-                }
-            }
-            block->free();
-        }
-    }
-    else
-    {
-        minstd_rand0 generator(rand());
-        switch(fun)
-        {
-            case P_ROW_BPR_MFOC:
-            {
-                uniform_int_distribution<mf_int> distribution(0, model.n-1);
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:error)
-#endif
-                for(mf_int i = 0; i < (mf_long)cv_block_ids.size(); ++i)
-                {
-                    BlockBase *block = blocks[cv_block_ids[i]];
-                    block->reload();
-                    while(block->move_next())
-                    {
-                        mf_node const &N = *(block->get_current());
-                        mf_int w = distribution(generator);
-                        error += log(1+exp(mf_predict(&model, N.u, w)-
-                                           mf_predict(&model, N.u, N.v)));
-                    }
-                    block->free();
-                }
-                break;
-            }
-            case P_COL_BPR_MFOC:
-            {
-                uniform_int_distribution<mf_int> distribution(0, model.m-1);
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:error)
-#endif
-                for(mf_int i = 0; i < (mf_long)cv_block_ids.size(); ++i)
-                {
-                    BlockBase *block = blocks[cv_block_ids[i]];
-                    block->reload();
-                    while(block->move_next())
-                    {
-                        mf_node const &N = *(block->get_current());
-                        mf_int w = distribution(generator);
-                        error += log(1+exp(mf_predict(&model, w, N.v)-
-                                           mf_predict(&model, N.u, N.v)));
-                    }
-                    block->free();
-                }
-                break;
-            }
-            default:
-            {
-                throw invalid_argument("unknown error function");
-                break;
-            }
-        }
-    }
-
-    return error;
-}
-
-string Utility::get_error_legend() const
-{
-    switch(fun)
-    {
-        case P_L2_MFR:
-            return string("rmse");
-            break;
-        case P_L1_MFR:
-            return string("mae");
-            break;
-        case P_KL_MFR:
-            return string("gkl");
-            break;
-        case P_LR_MFC:
-            return string("logloss");
-            break;
-        case P_L2_MFC:
-        case P_L1_MFC:
-            return string("accuracy");
-            break;
-        case P_ROW_BPR_MFOC:
-        case P_COL_BPR_MFOC:
-            return string("bprloss");
-            break;
-        case P_L2_MFOC:
-            return string("sqerror");
-        default:
-            return string();
-            break;
-     }
-}
-
-void Utility::shuffle_problem(
-    mf_problem &prob,
-    vector<mf_int> &p_map,
-    vector<mf_int> &q_map)
-{
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static)
-#endif
-    for(mf_long i = 0; i < prob.nnz; ++i)
-    {
-        mf_node &N = prob.R[i];
-        if(N.u < (mf_long)p_map.size())
-            N.u = p_map[N.u];
-        if(N.v < (mf_long)q_map.size())
-            N.v = q_map[N.v];
-    }
-}
-
-vector<mf_node*> Utility::grid_problem(
-    mf_problem &prob,
-    mf_int nr_bins,
-    vector<mf_int> &omega_p,
-    vector<mf_int> &omega_q,
-    vector<Block> &blocks)
-{
-    vector<mf_long> counts(nr_bins*nr_bins, 0);
-
-    mf_int seg_p = (mf_int)ceil((double)prob.m/nr_bins);
-    mf_int seg_q = (mf_int)ceil((double)prob.n/nr_bins);
-
-    auto get_block_id = [=] (mf_int u, mf_int v)
-    {
-        return (u/seg_p)*nr_bins+v/seg_q;
-    };
-
-    for(mf_long i = 0; i < prob.nnz; ++i)
-    {
-        mf_node &N = prob.R[i];
-        mf_int block = get_block_id(N.u, N.v);
-        counts[block] += 1;
-        omega_p[N.u] += 1;
-        omega_q[N.v] += 1;
-    }
-
-    vector<mf_node*> ptrs(nr_bins*nr_bins+1);
-    mf_node *ptr = prob.R;
-    ptrs[0] = ptr;
-    for(mf_int block = 0; block < nr_bins*nr_bins; ++block)
-        ptrs[block+1] = ptrs[block] + counts[block];
-
-    vector<mf_node*> pivots(ptrs.begin(), ptrs.end()-1);
-    for(mf_int block = 0; block < nr_bins*nr_bins; ++block)
-    {
-        for(mf_node* pivot = pivots[block]; pivot != ptrs[block+1];)
-        {
-            mf_int curr_block = get_block_id(pivot->u, pivot->v);
-            if(curr_block == block)
-            {
-                ++pivot;
-                continue;
-            }
-
-            mf_node *next = pivots[curr_block];
-            swap(*pivot, *next);
-            pivots[curr_block] += 1;
-        }
-    }
-
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(dynamic)
-#endif
-    for(mf_int block = 0; block < nr_bins*nr_bins; ++block)
-    {
-        if(prob.m > prob.n)
-            sort(ptrs[block], ptrs[block+1], sort_node_by_p());
-        else
-            sort(ptrs[block], ptrs[block+1], sort_node_by_q());
-    }
-
-    for(mf_int i = 0; i < (mf_long)blocks.size(); ++i)
-        blocks[i].tie_to(ptrs[i], ptrs[i+1]);
-
-    return ptrs;
-}
-
-void Utility::grid_shuffle_scale_problem_on_disk(
-    mf_int m, mf_int n, mf_int nr_bins,
-    mf_float scale, string data_path,
-    vector<mf_int> &p_map, vector<mf_int> &q_map,
-    vector<mf_int> &omega_p, vector<mf_int> &omega_q,
-    vector<BlockOnDisk> &blocks)
-{
-    string const buffer_path = data_path+string(".disk");
-    mf_int seg_p = (mf_int)ceil((double)m/nr_bins);
-    mf_int seg_q = (mf_int)ceil((double)n/nr_bins);
-    vector<mf_long> counts(nr_bins*nr_bins+1, 0);
-    vector<mf_long> pivots(nr_bins*nr_bins, 0);
-    ifstream source(data_path);
-    fstream buffer(buffer_path, fstream::in|fstream::out|
-                   fstream::binary|fstream::trunc);
-    auto get_block_id = [=] (mf_int u, mf_int v)
-    {
-        return (u/seg_p)*nr_bins+v/seg_q;
-    };
-
-    if(!source)
-        throw ios::failure(string("cannot to open ")+data_path);
-    if(!buffer)
-        throw ios::failure(string("cannot to open ")+buffer_path);
-
-    for(mf_node N; source >> N.u >> N.v >> N.r;)
-    {
-        N.u = p_map[N.u];
-        N.v = q_map[N.v];
-        mf_int bid = get_block_id(N.u, N.v);
-        omega_p[N.u] += 1;
-        omega_q[N.v] += 1;
-        counts[bid+1] += 1;
-    }
-
-    for(mf_int i = 1; i < nr_bins*nr_bins+1; ++i)
-    {
-        counts[i] += counts[i-1];
-        pivots[i-1] = counts[i-1];
-    }
-
-    source.clear();
-    source.seekg(0);
-    for(mf_node N; source >> N.u >> N.v >> N.r;)
-    {
-        N.u = p_map[N.u];
-        N.v = q_map[N.v];
-        N.r /= scale;
-        mf_int bid = get_block_id(N.u, N.v);
-        buffer.seekp(pivots[bid]*sizeof(mf_node));
-        buffer.write((char*)&N, sizeof(mf_node));
-        pivots[bid] += 1;
-    }
-
-    for(mf_int i = 0; i < nr_bins*nr_bins; ++i)
-    {
-        vector<mf_node> nodes(static_cast<size_t>(counts[i+1]-counts[i]));
-        buffer.clear();
-        buffer.seekg(counts[i]*sizeof(mf_node));
-        buffer.read((char*)nodes.data(), sizeof(mf_node)*nodes.size());
-
-        if(m > n)
-            sort(nodes.begin(), nodes.end(), sort_node_by_p());
-        else
-            sort(nodes.begin(), nodes.end(), sort_node_by_q());
-
-        buffer.clear();
-        buffer.seekp(counts[i]*sizeof(mf_node));
-        buffer.write((char*)nodes.data(), sizeof(mf_node)*nodes.size());
-        buffer.read((char*)nodes.data(), sizeof(mf_node)*nodes.size());
-    }
-
-    for(mf_int i = 0; i < (mf_long)blocks.size(); ++i)
-        blocks[i].tie_to(buffer_path, counts[i], counts[i+1]);
-}
-
-mf_float* Utility::malloc_aligned_float(mf_long size)
-{
-    // Check if conversion from mf_long to size_t causes overflow.
-    if (size > numeric_limits<std::size_t>::max() / sizeof(mf_float) + 1)
-        throw bad_alloc();
-    // [REVIEW] I hope one day we can use C11 aligned_alloc to replace
-    // platform-depedent functions below. Both of Windows and OSX currently
-    // don't support that function.
-    void *ptr = nullptr;
-#ifdef _WIN32
-    ptr = _aligned_malloc(static_cast<size_t>(size*sizeof(mf_float)),
-            kALIGNByte);
-#else
-    int status = posix_memalign(&ptr, kALIGNByte, size*sizeof(mf_float));
-        if(status != 0)
-                    throw bad_alloc();
-#endif
-    if(ptr == nullptr)
-        throw bad_alloc();
-
-    return (mf_float*)ptr;
-}
-
-void Utility::free_aligned_float(mf_float *ptr)
-{
-#ifdef _WIN32
-    // Unfortunately, Visual Studio doesn't want to support the
-    // cross-platform allocation below.
-    _aligned_free(ptr);
-#else
-    free(ptr);
-#endif
-}
-
-mf_model* Utility::init_model(mf_int fun,
-                              mf_int m, mf_int n,
-                              mf_int k, mf_float avg,
-                              vector<mf_int> &omega_p,
-                              vector<mf_int> &omega_q)
-{
-    mf_int k_real = k;
-    mf_int k_aligned = (mf_int)ceil(mf_double(k)/kALIGN)*kALIGN;
-
-    mf_model *model = new mf_model;
-
-    model->fun = fun;
-    model->m = m;
-    model->n = n;
-    model->k = k_aligned;
-    model->b = avg;
-    model->P = nullptr;
-    model->Q = nullptr;
-
-    mf_float scale = (mf_float)sqrt(1.0/k_real);
-    default_random_engine generator;
-    uniform_real_distribution<mf_float> distribution(0.0, 1.0);
-
-    try
-    {
-        model->P = Utility::malloc_aligned_float((mf_long)model->m*model->k);
-        model->Q = Utility::malloc_aligned_float((mf_long)model->n*model->k);
-    }
-    catch(bad_alloc const &e)
-    {
-        cerr << e.what() << endl;
-        mf_destroy_model(&model);
-        throw;
-    }
-
-    auto init1 = [&](mf_float *start_ptr, mf_long size, vector<mf_int> counts)
-    {
-        memset(start_ptr, 0, static_cast<size_t>(
-                    sizeof(mf_float) * size*model->k));
-        for(mf_long i = 0; i < size; ++i)
-        {
-            mf_float * ptr = start_ptr + i*model->k;
-            if(counts[static_cast<size_t>(i)] > 0)
-                for(mf_long d = 0; d < k_real; ++d, ++ptr)
-                    *ptr = (mf_float)(distribution(generator)*scale);
-            else
-                if(fun != P_ROW_BPR_MFOC && fun != P_COL_BPR_MFOC) // unseen for bpr is 0
-                    for(mf_long d = 0; d < k_real; ++d, ++ptr)
-                        *ptr = numeric_limits<mf_float>::quiet_NaN();
-        }
-    };
-
-    init1(model->P, m, omega_p);
-    init1(model->Q, n, omega_q);
-
-    return model;
-}
-
-// Initialize P=[\bar{p}_1, ..., \bar{p}_d] and Q=[\bar{q}_1, ..., \bar{q}_d].
-// Note that \bar{q}_{kv} is Q[k*n+v] and \bar{p}_{ku} is P[k*m+u].  One may
-// notice that P and Q here are actually the transposes of P and Q in fpsg(...)
-// because fpsg(...) uses P^TQ (where P and Q are respectively k-by-m and
-// k-by-n) to approximate the given rating matrix R while ccd_one_class(...)
-// uses PQ^T (where P and Q are respectively m-by-k and n-by-k.
-mf_model* Utility::init_model(mf_int m, mf_int n, mf_int k)
-{
-    mf_model *model = new mf_model;
-
-    model->fun = P_L2_MFOC;
-    model->m = m;
-    model->n = n;
-    model->k = k;
-    model->b = 0.0; // One-class matrix factorization doesn't have bias.
-    model->P = nullptr;
-    model->Q = nullptr;
-
-    try
-    {
-        model->P = Utility::malloc_aligned_float((mf_long)model->m*model->k);
-        model->Q = Utility::malloc_aligned_float((mf_long)model->n*model->k);
-    }
-    catch(bad_alloc const &e)
-    {
-        cerr << e.what() << endl;
-        mf_destroy_model(&model);
-        throw;
-    }
-
-    // Our initialization strategy is that all P's elements are zero and do
-    // random initization on Q. Thus, all initial predicted ratings are all zero
-    // since the approximated rating matrix is PQ^T.
-
-    // Initialize P with zeros
-    for(mf_long i = 0; i < k * m; ++i)
-        model->P[i] = 0.0;
-
-    // Initialize Q with random numbers
-    default_random_engine generator;
-    uniform_real_distribution<mf_float> distribution(0.0, 1.0);
-    for(mf_long i = 0; i < k * n; ++i)
-        model->Q[i] = distribution(generator);
-
-    return model;
-}
-
-vector<mf_int> Utility::gen_random_map(mf_int size)
-{
-    srand(0);
-    vector<mf_int> map(size, 0);
-    for(mf_int i = 0; i < size; ++i)
-        map[i] = i;
-    random_shuffle(map.begin(), map.end());
-    return map;
-}
-
-vector<mf_int> Utility::gen_inv_map(vector<mf_int> &map)
-{
-    vector<mf_int> inv_map(map.size());
-    for(mf_int i = 0; i < (mf_long)map.size(); ++i)
-      inv_map[map[i]] = i;
-    return inv_map;
-}
-
-void Utility::shuffle_model(
-    mf_model &model,
-    vector<mf_int> &p_map,
-    vector<mf_int> &q_map)
-{
-    auto inv_shuffle1 = [] (mf_float *vec, vector<mf_int> &map,
-                            mf_int size, mf_int k)
-    {
-        for(mf_int pivot = 0; pivot < size;)
-        {
-            if(pivot == map[pivot])
-            {
-                ++pivot;
-                continue;
-            }
-
-            mf_int next = map[pivot];
-
-            for(mf_int d = 0; d < k; ++d)
-                swap(*(vec+(mf_long)pivot*k+d), *(vec+(mf_long)next*k+d));
-
-            map[pivot] = map[next];
-            map[next] = next;
-        }
-    };
-
-    inv_shuffle1(model.P, p_map, model.m, model.k);
-    inv_shuffle1(model.Q, q_map, model.n, model.k);
-}
-
-void Utility::shrink_model(mf_model &model, mf_int k_new)
-{
-    mf_int k_old = model.k;
-    model.k = k_new;
-
-    auto shrink1 = [&] (mf_float *ptr, mf_int size)
-    {
-        for(mf_int i = 0; i < size; ++i)
-        {
-            mf_float *src = ptr+(mf_long)i*k_old;
-            mf_float *dst = ptr+(mf_long)i*k_new;
-            copy(src, src+k_new, dst);
-        }
-    };
-
-    shrink1(model.P, model.m);
-    shrink1(model.Q, model.n);
-}
-
-mf_problem* Utility::copy_problem(mf_problem const *prob, bool copy_data)
-{
-    mf_problem *new_prob = new mf_problem;
-
-    if(prob == nullptr)
-    {
-        new_prob->m = 0;
-        new_prob->n = 0;
-        new_prob->nnz = 0;
-        new_prob->R = nullptr;
-
-        return new_prob;
-    }
-
-    new_prob->m = prob->m;
-    new_prob->n = prob->n;
-    new_prob->nnz = prob->nnz;
-
-    if(copy_data)
-    {
-        try
-        {
-            new_prob->R = new mf_node[static_cast<size_t>(prob->nnz)];
-            copy(prob->R, prob->R+prob->nnz, new_prob->R);
-        }
-        catch(...)
-        {
-            delete new_prob;
-            throw;
-        }
-    }
-    else
-    {
-        new_prob->R = prob->R;
-    }
-
-    return new_prob;
-}
-
-//--------------------------------------
-//-----The base class of all solvers----
-//--------------------------------------
-
-class SolverBase
-{
-public:
-    SolverBase(Scheduler &scheduler, vector<BlockBase*> &blocks,
-               mf_float *PG, mf_float *QG, mf_model &model, mf_parameter param,
-               bool &slow_only)
-        : scheduler(scheduler), blocks(blocks), PG(PG), QG(QG),
-          model(model), param(param), slow_only(slow_only) {}
-    void run();
-    SolverBase(const SolverBase&) = delete;
-    SolverBase& operator=(const SolverBase&) = delete;
-    // Solver is stateless functor, so default destructor should be
-    // good enough.
-    virtual ~SolverBase() = default;
-
-protected:
-#if defined USESSE
-    static void calc_z(__m128 &XMMz, mf_int k, mf_float *p, mf_float *q);
-    virtual void load_fixed_variables(
-        __m128 &XMMlambda_p1, __m128 &XMMlambda_q1,
-        __m128 &XMMlambda_p2, __m128 &XMMlabmda_q2,
-        __m128 &XMMeta, __m128 &XMMrk_slow,
-        __m128 &XMMrk_fast);
-    virtual void arrange_block(__m128d &XMMloss, __m128d &XMMerror);
-    virtual void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror) = 0;
-    virtual void sg_update(mf_int d_begin, mf_int d_end, __m128 XMMz,
-                           __m128 XMMlambda_p1, __m128 XMMlambda_q1,
-                           __m128 XMMlambda_p2, __m128 XMMlamdba_q2,
-                           __m128 XMMeta, __m128 XMMrk) = 0;
-    virtual void finalize(__m128d XMMloss, __m128d XMMerror);
-#elif defined USEAVX
-    static void calc_z(__m256 &XMMz, mf_int k, mf_float *p, mf_float *q);
-    virtual void load_fixed_variables(
-        __m256 &XMMlambda_p1, __m256 &XMMlambda_q1,
-        __m256 &XMMlambda_p2, __m256 &XMMlabmda_q2,
-        __m256 &XMMeta, __m256 &XMMrk_slow,
-        __m256 &XMMrk_fast);
-    virtual void arrange_block(__m128d &XMMloss, __m128d &XMMerror);
-    virtual void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror) = 0;
-    virtual void sg_update(mf_int d_begin, mf_int d_end, __m256 XMMz,
-                           __m256 XMMlambda_p1, __m256 XMMlambda_q1,
-                           __m256 XMMlambda_p2, __m256 XMMlamdba_q2,
-                           __m256 XMMeta, __m256 XMMrk) = 0;
-    virtual void finalize(__m128d XMMloss, __m128d XMMerror);
-#else
-    static void calc_z(mf_float &z, mf_int k, mf_float *p, mf_float *q);
-    virtual void load_fixed_variables();
-    virtual void arrange_block();
-    virtual void prepare_for_sg_update() = 0;
-    virtual void sg_update(mf_int d_begin, mf_int d_end, mf_float rk) = 0;
-    virtual void finalize();
-    static float qrsqrt(float x);
-#endif
-    virtual void update() { ++pG; ++qG; };
-
-    Scheduler &scheduler;
-    vector<BlockBase*> &blocks;
-    BlockBase *block;
-    mf_float *PG;
-    mf_float *QG;
-    mf_model &model;
-    mf_parameter param;
-    bool &slow_only;
-
-    mf_node *N;
-    mf_float z;
-    mf_double loss;
-    mf_double error;
-    mf_float *p;
-    mf_float *q;
-    mf_float *pG;
-    mf_float *qG;
-    mf_int bid;
-
-    mf_float lambda_p1;
-    mf_float lambda_q1;
-    mf_float lambda_p2;
-    mf_float lambda_q2;
-    mf_float rk_slow;
-    mf_float rk_fast;
-};
-
-#if defined USESSE
-inline void SolverBase::run()
-{
-    __m128d XMMloss;
-    __m128d XMMerror;
-    __m128 XMMz;
-    __m128 XMMlambda_p1;
-    __m128 XMMlambda_q1;
-    __m128 XMMlambda_p2;
-    __m128 XMMlambda_q2;
-    __m128 XMMeta;
-    __m128 XMMrk_slow;
-    __m128 XMMrk_fast;
-    load_fixed_variables(XMMlambda_p1, XMMlambda_q1,
-                         XMMlambda_p2, XMMlambda_q2,
-                         XMMeta, XMMrk_slow,
-                         XMMrk_fast);
-    while(!scheduler.is_terminated())
-    {
-        arrange_block(XMMloss, XMMerror);
-        while(block->move_next())
-        {
-            N = block->get_current();
-            p = model.P+(mf_long)N->u*model.k;
-            q = model.Q+(mf_long)N->v*model.k;
-            pG = PG+N->u*2;
-            qG = QG+N->v*2;
-            prepare_for_sg_update(XMMz, XMMloss, XMMerror);
-            sg_update(0, kALIGN, XMMz, XMMlambda_p1, XMMlambda_q1,
-                    XMMlambda_p2, XMMlambda_q2, XMMeta, XMMrk_slow);
-            if(slow_only)
-                continue;
-            update();
-            sg_update(kALIGN, model.k, XMMz, XMMlambda_p1, XMMlambda_q1,
-                    XMMlambda_p2, XMMlambda_q2, XMMeta, XMMrk_slow);
-        }
-        finalize(XMMloss, XMMerror);
-    }
-}
-
-void SolverBase::load_fixed_variables(
-    __m128 &XMMlambda_p1, __m128 &XMMlambda_q1,
-    __m128 &XMMlambda_p2, __m128 &XMMlambda_q2,
-    __m128 &XMMeta, __m128 &XMMrk_slow,
-    __m128 &XMMrk_fast)
-{
-    XMMlambda_p1 = _mm_set1_ps(param.lambda_p1);
-    XMMlambda_q1 = _mm_set1_ps(param.lambda_q1);
-    XMMlambda_p2 = _mm_set1_ps(param.lambda_p2);
-    XMMlambda_q2 = _mm_set1_ps(param.lambda_q2);
-    XMMeta = _mm_set1_ps(param.eta);
-    XMMrk_slow = _mm_set1_ps((mf_float)1.0/kALIGN);
-    XMMrk_fast = _mm_set1_ps((mf_float)1.0/(model.k-kALIGN));
-}
-
-void SolverBase::arrange_block(__m128d &XMMloss, __m128d &XMMerror)
-{
-    XMMloss = _mm_setzero_pd();
-    XMMerror = _mm_setzero_pd();
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-}
-
-inline void SolverBase::calc_z(
-    __m128 &XMMz, mf_int k, mf_float *p, mf_float *q)
-{
-    XMMz = _mm_setzero_ps();
-    for(mf_int d = 0; d < k; d += 4)
-        XMMz = _mm_add_ps(XMMz, _mm_mul_ps(
-               _mm_load_ps(p+d), _mm_load_ps(q+d)));
-    // Bit-wise representation of 177 is {1,0}+{1,1}+{0,0}+{0,1} from
-    // high-bit to low-bit, where "+" means concatenating two arrays.
-    __m128 XMMtmp = _mm_add_ps(XMMz, _mm_shuffle_ps(XMMz, XMMz, 177));
-    // Bit-wise representation of 78 is {0,1}+{0,0}+{1,1}+{1,0} from
-    // high-bit to low-bit, where "+" means concatenating two arrays.
-    XMMz = _mm_add_ps(XMMtmp, _mm_shuffle_ps(XMMtmp, XMMtmp, 78));
-}
-
-void SolverBase::finalize(__m128d XMMloss, __m128d XMMerror)
-{
-    _mm_store_sd(&loss, XMMloss);
-    _mm_store_sd(&error, XMMerror);
-    block->free();
-    scheduler.put_job(bid, loss, error);
-}
-#elif defined USEAVX
-inline void SolverBase::run()
-{
-    __m128d XMMloss;
-    __m128d XMMerror;
-    __m256 XMMz;
-    __m256 XMMlambda_p1;
-    __m256 XMMlambda_q1;
-    __m256 XMMlambda_p2;
-    __m256 XMMlambda_q2;
-    __m256 XMMeta;
-    __m256 XMMrk_slow;
-    __m256 XMMrk_fast;
-    load_fixed_variables(XMMlambda_p1, XMMlambda_q1,
-                         XMMlambda_p2, XMMlambda_q2,
-                         XMMeta, XMMrk_slow, XMMrk_fast);
-    while(!scheduler.is_terminated())
-    {
-        arrange_block(XMMloss, XMMerror);
-        while(block->move_next())
-        {
-            N = block->get_current();
-            p = model.P+(mf_long)N->u*model.k;
-            q = model.Q+(mf_long)N->v*model.k;
-            pG = PG+N->u*2;
-            qG = QG+N->v*2;
-            prepare_for_sg_update(XMMz, XMMloss, XMMerror);
-            sg_update(0, kALIGN, XMMz, XMMlambda_p1, XMMlambda_q1,
-                      XMMlambda_p2, XMMlambda_q2, XMMeta, XMMrk_slow);
-            if(slow_only)
-                continue;
-            update();
-            sg_update(kALIGN, model.k, XMMz, XMMlambda_p1, XMMlambda_q1,
-                      XMMlambda_p2, XMMlambda_q2, XMMeta, XMMrk_fast);
-        }
-        finalize(XMMloss, XMMerror);
-    }
-}
-
-void SolverBase::load_fixed_variables(
-    __m256 &XMMlambda_p1, __m256 &XMMlambda_q1,
-    __m256 &XMMlambda_p2, __m256 &XMMlambda_q2,
-    __m256 &XMMeta, __m256 &XMMrk_slow,
-    __m256 &XMMrk_fast)
-{
-    XMMlambda_p1 = _mm256_set1_ps(param.lambda_p1);
-    XMMlambda_q1 = _mm256_set1_ps(param.lambda_q1);
-    XMMlambda_p2 = _mm256_set1_ps(param.lambda_p2);
-    XMMlambda_q2 = _mm256_set1_ps(param.lambda_q2);
-    XMMeta = _mm256_set1_ps(param.eta);
-    XMMrk_slow = _mm256_set1_ps((mf_float)1.0/kALIGN);
-    XMMrk_fast = _mm256_set1_ps((mf_float)1.0/(model.k-kALIGN));
-}
-
-void SolverBase::arrange_block(__m128d &XMMloss, __m128d &XMMerror)
-{
-    XMMloss = _mm_setzero_pd();
-    XMMerror = _mm_setzero_pd();
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-}
-
-inline void SolverBase::calc_z(
-    __m256 &XMMz, mf_int k, mf_float *p, mf_float *q)
-{
-    XMMz = _mm256_setzero_ps();
-    for(mf_int d = 0; d < k; d += 8)
-        XMMz = _mm256_add_ps(XMMz, _mm256_mul_ps(
-               _mm256_load_ps(p+d), _mm256_load_ps(q+d)));
-    XMMz = _mm256_add_ps(XMMz, _mm256_permute2f128_ps(XMMz, XMMz, 0x1));
-    XMMz = _mm256_hadd_ps(XMMz, XMMz);
-    XMMz = _mm256_hadd_ps(XMMz, XMMz);
-}
-
-void SolverBase::finalize(__m128d XMMloss, __m128d XMMerror)
-{
-    _mm_store_sd(&loss, XMMloss);
-    _mm_store_sd(&error, XMMerror);
-    block->free();
-    scheduler.put_job(bid, loss, error);
-}
-#else
-inline void SolverBase::run()
-{
-    load_fixed_variables();
-    while(!scheduler.is_terminated())
-    {
-        arrange_block();
-        while(block->move_next())
-        {
-            N = block->get_current();
-            p = model.P+(mf_long)N->u*model.k;
-            q = model.Q+(mf_long)N->v*model.k;
-            pG = PG+N->u*2;
-            qG = QG+N->v*2;
-            prepare_for_sg_update();
-            sg_update(0, kALIGN, rk_slow);
-            if(slow_only)
-                continue;
-            update();
-            sg_update(kALIGN, model.k, rk_fast);
-        }
-        finalize();
-    }
-}
-
-inline float SolverBase::qrsqrt(float x)
-{
-    float xhalf = 0.5f*x;
-    uint32_t i;
-    memcpy(&i, &x, sizeof(i));
-    i = 0x5f375a86 - (i>>1);
-    memcpy(&x, &i, sizeof(i));
-    x = x*(1.5f - xhalf*x*x);
-    return x;
-}
-
-void SolverBase::load_fixed_variables()
-{
-    lambda_p1 = param.lambda_p1;
-    lambda_q1 = param.lambda_q1;
-    lambda_p2 = param.lambda_p2;
-    lambda_q2 = param.lambda_q2;
-    rk_slow = (mf_float)1.0/kALIGN;
-    rk_fast = (mf_float)1.0/(model.k-kALIGN);
-}
-
-void SolverBase::arrange_block()
-{
-    loss = 0.0;
-    error = 0.0;
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-}
-
-inline void SolverBase::calc_z(mf_float &z, mf_int k, mf_float *p, mf_float *q)
-{
-    z = 0;
-    for(mf_int d = 0; d < k; ++d)
-        z += p[d]*q[d];
-}
-
-void SolverBase::finalize()
-{
-    block->free();
-    scheduler.put_job(bid, loss, error);
-}
-#endif
-
-//--------------------------------------
-//-----Real-valued MF and binary MF-----
-//--------------------------------------
-
-class MFSolver: public SolverBase
-{
-public:
-    MFSolver(Scheduler &scheduler, vector<BlockBase*> &blocks,
-             mf_float *PG, mf_float *QG, mf_model &model,
-             mf_parameter param, bool &slow_only)
-        : SolverBase(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void sg_update(mf_int d_begin, mf_int d_end, __m128 XMMz,
-                   __m128 XMMlambda_p1, __m128 XMMlambda_q1,
-                   __m128 XMMlambda_p2, __m128 XMMlambda_q2,
-                   __m128 XMMeta, __m128 XMMrk);
-#elif defined USEAVX
-    void sg_update(mf_int d_begin, mf_int d_end, __m256 XMMz,
-                   __m256 XMMlambda_p1, __m256 XMMlambda_q1,
-                   __m256 XMMlambda_p2, __m256 XMMlambda_q2,
-                   __m256 XMMeta, __m256 XMMrk);
-#else
-    void sg_update(mf_int d_begin, mf_int d_end, mf_float rk);
-#endif
-};
-
-#if defined USESSE
-void MFSolver::sg_update(mf_int d_begin, mf_int d_end, __m128 XMMz,
-                                __m128 XMMlambda_p1, __m128 XMMlambda_q1,
-                                __m128 XMMlambda_p2, __m128 XMMlambda_q2,
-                                __m128 XMMeta, __m128 XMMrk)
-{
-    __m128 XMMpG = _mm_load1_ps(pG);
-    __m128 XMMqG = _mm_load1_ps(qG);
-    __m128 XMMeta_p = _mm_mul_ps(XMMeta, _mm_rsqrt_ps(XMMpG));
-    __m128 XMMeta_q = _mm_mul_ps(XMMeta, _mm_rsqrt_ps(XMMqG));
-    __m128 XMMpG1 = _mm_setzero_ps();
-    __m128 XMMqG1 = _mm_setzero_ps();
-
-    for(mf_int d = d_begin; d < d_end; d += 4)
-    {
-        __m128 XMMp = _mm_load_ps(p+d);
-        __m128 XMMq = _mm_load_ps(q+d);
-
-        __m128 XMMpg = _mm_sub_ps(_mm_mul_ps(XMMlambda_p2, XMMp),
-                       _mm_mul_ps(XMMz, XMMq));
-        __m128 XMMqg = _mm_sub_ps(_mm_mul_ps(XMMlambda_q2, XMMq),
-                       _mm_mul_ps(XMMz, XMMp));
-
-        XMMpG1 = _mm_add_ps(XMMpG1, _mm_mul_ps(XMMpg, XMMpg));
-        XMMqG1 = _mm_add_ps(XMMqG1, _mm_mul_ps(XMMqg, XMMqg));
-
-        XMMp = _mm_sub_ps(XMMp, _mm_mul_ps(XMMeta_p, XMMpg));
-        XMMq = _mm_sub_ps(XMMq, _mm_mul_ps(XMMeta_q, XMMqg));
-
-        _mm_store_ps(p+d, XMMp);
-        _mm_store_ps(q+d, XMMq);
-    }
-
-    mf_float tmp = 0;
-    _mm_store_ss(&tmp, XMMlambda_p1);
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMp = _mm_load_ps(p+d);
-            __m128 XMMflip = _mm_and_ps(_mm_cmple_ps(XMMp, _mm_set1_ps(0.0f)),
-                             _mm_set1_ps(-0.0f));
-            XMMp = _mm_xor_ps(XMMflip,
-                   _mm_max_ps(_mm_sub_ps(_mm_xor_ps(XMMp, XMMflip),
-                   _mm_mul_ps(XMMeta_p, XMMlambda_p1)), _mm_set1_ps(0.0f)));
-            _mm_store_ps(p+d, XMMp);
-        }
-    }
-
-    _mm_store_ss(&tmp, XMMlambda_q1);
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMq = _mm_load_ps(q+d);
-            __m128 XMMflip = _mm_and_ps(_mm_cmple_ps(XMMq, _mm_set1_ps(0.0f)),
-                             _mm_set1_ps(-0.0f));
-            XMMq = _mm_xor_ps(XMMflip,
-                   _mm_max_ps(_mm_sub_ps(_mm_xor_ps(XMMq, XMMflip),
-                   _mm_mul_ps(XMMeta_q, XMMlambda_q1)), _mm_set1_ps(0.0f)));
-            _mm_store_ps(q+d, XMMq);
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMp = _mm_load_ps(p+d);
-            __m128 XMMq = _mm_load_ps(q+d);
-            XMMp = _mm_max_ps(XMMp, _mm_set1_ps(0.0f));
-            XMMq = _mm_max_ps(XMMq, _mm_set1_ps(0.0f));
-            _mm_store_ps(p+d, XMMp);
-            _mm_store_ps(q+d, XMMq);
-        }
-    }
-
-    __m128 XMMtmp = _mm_add_ps(XMMpG1, _mm_movehl_ps(XMMpG1, XMMpG1));
-    XMMpG1 = _mm_add_ps(XMMpG1, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    XMMpG = _mm_add_ps(XMMpG, _mm_mul_ps(XMMpG1, XMMrk));
-    _mm_store_ss(pG, XMMpG);
-
-    XMMtmp = _mm_add_ps(XMMqG1, _mm_movehl_ps(XMMqG1, XMMqG1));
-    XMMqG1 = _mm_add_ps(XMMqG1, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    XMMqG = _mm_add_ps(XMMqG, _mm_mul_ps(XMMqG1, XMMrk));
-    _mm_store_ss(qG, XMMqG);
-}
-#elif defined USEAVX
-void MFSolver::sg_update(mf_int d_begin, mf_int d_end, __m256 XMMz,
-                                __m256 XMMlambda_p1, __m256 XMMlambda_q1,
-                                __m256 XMMlambda_p2, __m256 XMMlambda_q2,
-                                __m256 XMMeta, __m256 XMMrk)
-{
-    __m256 XMMpG = _mm256_broadcast_ss(pG);
-    __m256 XMMqG = _mm256_broadcast_ss(qG);
-    __m256 XMMeta_p = _mm256_mul_ps(XMMeta, _mm256_rsqrt_ps(XMMpG));
-    __m256 XMMeta_q = _mm256_mul_ps(XMMeta, _mm256_rsqrt_ps(XMMqG));
-    __m256 XMMpG1 = _mm256_setzero_ps();
-    __m256 XMMqG1 = _mm256_setzero_ps();
-
-    for(mf_int d = d_begin; d < d_end; d += 8)
-    {
-        __m256 XMMp = _mm256_load_ps(p+d);
-        __m256 XMMq = _mm256_load_ps(q+d);
-
-        __m256 XMMpg = _mm256_sub_ps(_mm256_mul_ps(XMMlambda_p2, XMMp),
-                                     _mm256_mul_ps(XMMz, XMMq));
-        __m256 XMMqg = _mm256_sub_ps(_mm256_mul_ps(XMMlambda_q2, XMMq),
-                                     _mm256_mul_ps(XMMz, XMMp));
-
-        XMMpG1 = _mm256_add_ps(XMMpG1, _mm256_mul_ps(XMMpg, XMMpg));
-        XMMqG1 = _mm256_add_ps(XMMqG1, _mm256_mul_ps(XMMqg, XMMqg));
-
-        XMMp = _mm256_sub_ps(XMMp, _mm256_mul_ps(XMMeta_p, XMMpg));
-        XMMq = _mm256_sub_ps(XMMq, _mm256_mul_ps(XMMeta_q, XMMqg));
-        _mm256_store_ps(p+d, XMMp);
-        _mm256_store_ps(q+d, XMMq);
-    }
-
-    mf_float tmp = 0;
-    _mm_store_ss(&tmp, _mm256_castps256_ps128(XMMlambda_p1));
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMp = _mm256_load_ps(p+d);
-            __m256 XMMflip = _mm256_and_ps(_mm256_cmp_ps(XMMp,
-                             _mm256_set1_ps(0.0f), _CMP_LE_OS),
-                             _mm256_set1_ps(-0.0f));
-            XMMp = _mm256_xor_ps(XMMflip,
-                   _mm256_max_ps(_mm256_sub_ps(
-                   _mm256_xor_ps(XMMp, XMMflip),
-                   _mm256_mul_ps(XMMeta_p, XMMlambda_p1)),
-                   _mm256_set1_ps(0.0f)));
-            _mm256_store_ps(p+d, XMMp);
-        }
-    }
-
-    _mm_store_ss(&tmp, _mm256_castps256_ps128(XMMlambda_q1));
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMq = _mm256_load_ps(q+d);
-            __m256 XMMflip = _mm256_and_ps(_mm256_cmp_ps(XMMq,
-                             _mm256_set1_ps(0.0f), _CMP_LE_OS),
-                             _mm256_set1_ps(-0.0f));
-            XMMq = _mm256_xor_ps(XMMflip,
-                   _mm256_max_ps(_mm256_sub_ps(
-                   _mm256_xor_ps(XMMq, XMMflip),
-                   _mm256_mul_ps(XMMeta_q, XMMlambda_q1)),
-                   _mm256_set1_ps(0.0f)));
-            _mm256_store_ps(q+d, XMMq);
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMp = _mm256_load_ps(p+d);
-            __m256 XMMq = _mm256_load_ps(q+d);
-            XMMp = _mm256_max_ps(XMMp, _mm256_set1_ps(0));
-            XMMq = _mm256_max_ps(XMMq, _mm256_set1_ps(0));
-            _mm256_store_ps(p+d, XMMp);
-            _mm256_store_ps(q+d, XMMq);
-        }
-    }
-
-    XMMpG1 = _mm256_add_ps(XMMpG1,
-             _mm256_permute2f128_ps(XMMpG1, XMMpG1, 0x1));
-    XMMpG1 = _mm256_hadd_ps(XMMpG1, XMMpG1);
-    XMMpG1 = _mm256_hadd_ps(XMMpG1, XMMpG1);
-
-    XMMqG1 = _mm256_add_ps(XMMqG1,
-             _mm256_permute2f128_ps(XMMqG1, XMMqG1, 0x1));
-    XMMqG1 = _mm256_hadd_ps(XMMqG1, XMMqG1);
-    XMMqG1 = _mm256_hadd_ps(XMMqG1, XMMqG1);
-
-    XMMpG = _mm256_add_ps(XMMpG, _mm256_mul_ps(XMMpG1, XMMrk));
-    XMMqG = _mm256_add_ps(XMMqG, _mm256_mul_ps(XMMqG1, XMMrk));
-
-    _mm_store_ss(pG, _mm256_castps256_ps128(XMMpG));
-    _mm_store_ss(qG, _mm256_castps256_ps128(XMMqG));
-}
-#else
-void MFSolver::sg_update(mf_int d_begin, mf_int d_end, mf_float rk)
-{
-    mf_float eta_p = param.eta*qrsqrt(*pG);
-    mf_float eta_q = param.eta*qrsqrt(*qG);
-
-    mf_float pG1 = 0;
-    mf_float qG1 = 0;
-
-    for(mf_int d = d_begin; d < d_end; ++d)
-    {
-        mf_float gp = -z*q[d]+lambda_p2*p[d];
-        mf_float gq = -z*p[d]+lambda_q2*q[d];
-
-        pG1 += gp*gp;
-        qG1 += gq*gq;
-
-        p[d] -= eta_p*gp;
-        q[d] -= eta_q*gq;
-    }
-
-    if(lambda_p1 > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            mf_float p1 = max(abs(p[d])-lambda_p1*eta_p, 0.0f);
-            p[d] = p[d] >= 0? p1: -p1;
-        }
-    }
-
-    if(lambda_q1 > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            mf_float q1 = max(abs(q[d])-lambda_q1*eta_q, 0.0f);
-            q[d] = q[d] >= 0? q1: -q1;
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            p[d] = max(p[d], (mf_float)0.0f);
-            q[d] = max(q[d], (mf_float)0.0f);
-        }
-    }
-
-    *pG += pG1*rk;
-    *qG += qG1*rk;
-}
-#endif
-
-class L2_MFR : public MFSolver
-{
-public:
-    L2_MFR(Scheduler &scheduler, vector<BlockBase*> &blocks, mf_float *PG, mf_float *QG,
-           mf_model &model, mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void L2_MFR::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm_sub_ps(_mm_set1_ps(N->r), XMMz);
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_mul_ps(XMMz, XMMz)));
-    XMMerror = XMMloss;
-}
-#elif defined USEAVX
-void L2_MFR::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm256_sub_ps(_mm256_set1_ps(N->r), XMMz);
-    XMMloss = _mm_add_pd(XMMloss,
-              _mm_cvtps_pd(_mm256_castps256_ps128(
-              _mm256_mul_ps(XMMz, XMMz))));
-    XMMerror = XMMloss;
-}
-#else
-void L2_MFR::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    z = N->r-z;
-    loss += z*z;
-    error = loss;
-}
-#endif
-class L1_MFR : public MFSolver
-{
-public:
-    L1_MFR(Scheduler &scheduler, vector<BlockBase*> &blocks, mf_float *PG, mf_float *QG,
-           mf_model &model, mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void L1_MFR::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm_sub_ps(_mm_set1_ps(N->r), XMMz);
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_andnot_ps(_mm_set1_ps(-0.0f), XMMz)));
-    XMMerror = XMMloss;
-    XMMz = _mm_add_ps(_mm_and_ps(_mm_cmpgt_ps(XMMz, _mm_set1_ps(0.0f)),
-           _mm_set1_ps(1.0f)),
-           _mm_and_ps(_mm_cmplt_ps(XMMz, _mm_set1_ps(0.0f)),
-           _mm_set1_ps(-1.0f)));
-}
-#elif defined USEAVX
-void L1_MFR::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm256_sub_ps(_mm256_set1_ps(N->r), XMMz);
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(_mm256_castps256_ps128(
-              _mm256_andnot_ps(_mm256_set1_ps(-0.0f), XMMz))));
-    XMMerror = XMMloss;
-    XMMz = _mm256_add_ps(_mm256_and_ps(_mm256_cmp_ps(XMMz,
-           _mm256_set1_ps(0.0f), _CMP_GT_OS), _mm256_set1_ps(1.0f)),
-           _mm256_and_ps(_mm256_cmp_ps(XMMz,
-           _mm256_set1_ps(0.0f), _CMP_LT_OS), _mm256_set1_ps(-1.0f)));
-}
-#else
-void L1_MFR::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    z = N->r-z;
-    loss += abs(z);
-    error = loss;
-    if(z > 0)
-        z = 1;
-    else if(z < 0)
-        z = -1;
-}
-#endif
-
-class KL_MFR : public MFSolver
-{
-public:
-    KL_MFR(Scheduler &scheduler, vector<BlockBase*> &blocks, mf_float *PG, mf_float *QG,
-           mf_model &model, mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void KL_MFR::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm_div_ps(_mm_set1_ps(N->r), XMMz);
-    _mm_store_ss(&z, XMMz);
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_set1_ps(N->r*(log(z)-1+1/z))));
-    XMMerror = XMMloss;
-    XMMz = _mm_sub_ps(XMMz, _mm_set1_ps(1.0f));
-}
-#elif defined USEAVX
-void KL_MFR::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    XMMz = _mm256_div_ps(_mm256_set1_ps(N->r), XMMz);
-    _mm_store_ss(&z, _mm256_castps256_ps128(XMMz));
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_set1_ps(N->r*(log(z)-1+1/z))));
-    XMMerror = XMMloss;
-    XMMz = _mm256_sub_ps(XMMz, _mm256_set1_ps(1.0f));
-}
-#else
-void KL_MFR::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    z = N->r/z;
-    loss += N->r*(log(z)-1+1/z);
-    error = loss;
-    z -= 1;
-}
-#endif
-
-class LR_MFC : public MFSolver
-{
-public:
-    LR_MFC(Scheduler &scheduler, vector<BlockBase*> &blocks,
-           mf_float *PG, mf_float *QG, mf_model &model,
-           mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void LR_MFC::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    _mm_store_ss(&z, XMMz);
-    if(N->r > 0)
-    {
-        z = exp(-z);
-        XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1+z)));
-        XMMz = _mm_set1_ps(z/(1+z));
-    }
-    else
-    {
-        z = exp(z);
-        XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1+z)));
-        XMMz = _mm_set1_ps(-z/(1+z));
-    }
-    XMMerror = XMMloss;
-}
-#elif defined USEAVX
-void LR_MFC::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    _mm_store_ss(&z, _mm256_castps256_ps128(XMMz));
-    if(N->r > 0)
-    {
-        z = exp(-z);
-        XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1.0+z)));
-        XMMz = _mm256_set1_ps(z/(1+z));
-    }
-    else
-    {
-        z = exp(z);
-        XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1.0+z)));
-        XMMz = _mm256_set1_ps(-z/(1+z));
-    }
-    XMMerror = XMMloss;
-}
-#else
-void LR_MFC::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    if(N->r > 0)
-    {
-        z = exp(-z);
-        loss += log(1+z);
-        error = loss;
-        z = z/(1+z);
-    }
-    else
-    {
-        z = exp(z);
-        loss += log(1+z);
-        error = loss;
-        z = -z/(1+z);
-    }
-}
-#endif
-
-class L2_MFC : public MFSolver
-{
-public:
-    L2_MFC(Scheduler &scheduler, vector<BlockBase*> &blocks,
-           mf_float *PG, mf_float *QG, mf_model &model,
-           mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void L2_MFC::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    if(N->r > 0)
-    {
-        __m128 mask = _mm_cmpgt_ps(XMMz, _mm_set1_ps(0.0f));
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_set1_ps(1.0f), mask)));
-        XMMz = _mm_max_ps(_mm_set1_ps(0.0f), _mm_sub_ps(
-               _mm_set1_ps(1.0f), XMMz));
-    }
-    else
-    {
-        __m128 mask = _mm_cmplt_ps(XMMz, _mm_set1_ps(0.0f));
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_set1_ps(1.0f), mask)));
-        XMMz = _mm_min_ps(_mm_set1_ps(0.0f), _mm_sub_ps(
-               _mm_set1_ps(-1.0f), XMMz));
-    }
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_mul_ps(XMMz, XMMz)));
-}
-#elif defined USEAVX
-void L2_MFC::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    if(N->r > 0)
-    {
-        __m128 mask = _mm_cmpgt_ps(_mm256_castps256_ps128(XMMz),
-                      _mm_set1_ps(0.0f));
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_set1_ps(1.0f), mask)));
-        XMMz = _mm256_max_ps(_mm256_set1_ps(0.0f),
-               _mm256_sub_ps(_mm256_set1_ps(1.0f), XMMz));
-    }
-    else
-    {
-        __m128 mask = _mm_cmplt_ps(_mm256_castps256_ps128(XMMz),
-                      _mm_set1_ps(0.0f));
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_set1_ps(1.0f), mask)));
-        XMMz = _mm256_min_ps(_mm256_set1_ps(0.0f),
-               _mm256_sub_ps(_mm256_set1_ps(-1.0f), XMMz));
-    }
-    XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-              _mm_mul_ps(_mm256_castps256_ps128(XMMz),
-              _mm256_castps256_ps128(XMMz))));
-}
-#else
-void L2_MFC::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    if(N->r > 0)
-    {
-        error += z > 0? 1: 0;
-        z = max(0.0f, 1-z);
-    }
-    else
-    {
-        error += z < 0? 1: 0;
-        z = min(0.0f, -1-z);
-    }
-    loss += z*z;
-}
-#endif
-
-class L1_MFC : public MFSolver
-{
-public:
-    L1_MFC(Scheduler &scheduler, vector<BlockBase*> &blocks, mf_float *PG, mf_float *QG,
-           mf_model &model, mf_parameter param, bool &slow_only)
-        : MFSolver(scheduler, blocks, PG, QG, model, param, slow_only) {}
-
-protected:
-#if defined USESSE
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#elif defined USEAVX
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-#else
-    void prepare_for_sg_update();
-#endif
-};
-
-#if defined USESSE
-void L1_MFC::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    if(N->r > 0)
-    {
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_cmpge_ps(XMMz, _mm_set1_ps(0.0f)),
-                   _mm_set1_ps(1.0f))));
-        XMMz = _mm_sub_ps(_mm_set1_ps(1.0f), XMMz);
-        XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-                  _mm_max_ps(_mm_set1_ps(0.0f), XMMz)));
-        XMMz = _mm_and_ps(_mm_cmpge_ps(XMMz, _mm_set1_ps(0.0f)),
-               _mm_set1_ps(1.0f));
-    }
-    else
-    {
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(
-                   _mm_and_ps(_mm_cmplt_ps(XMMz, _mm_set1_ps(0.0f)),
-                   _mm_set1_ps(1.0f))));
-        XMMz = _mm_add_ps(_mm_set1_ps(1.0f), XMMz);
-        XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(
-                  _mm_max_ps(_mm_set1_ps(0.0f), XMMz)));
-        XMMz = _mm_and_ps(_mm_cmpge_ps(XMMz, _mm_set1_ps(0.0f)),
-               _mm_set1_ps(-1.0f));
-    }
-}
-#elif defined USEAVX
-void L1_MFC::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    calc_z(XMMz, model.k, p, q);
-    if(N->r > 0)
-    {
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(_mm_and_ps(
-                   _mm_cmpge_ps(_mm256_castps256_ps128(XMMz),
-                   _mm_set1_ps(0.0f)), _mm_set1_ps(1.0f))));
-        XMMz = _mm256_sub_ps(_mm256_set1_ps(1.0f), XMMz);
-        XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(_mm_max_ps(
-                  _mm_set1_ps(0.0f), _mm256_castps256_ps128(XMMz))));
-        XMMz = _mm256_and_ps(_mm256_cmp_ps(XMMz, _mm256_set1_ps(0.0f),
-               _CMP_GE_OS), _mm256_set1_ps(1.0f));
-    }
-    else
-    {
-        XMMerror = _mm_add_pd(XMMerror, _mm_cvtps_pd(_mm_and_ps(
-                   _mm_cmplt_ps(_mm256_castps256_ps128(XMMz),
-                   _mm_set1_ps(0.0f)), _mm_set1_ps(1.0f))));
-        XMMz = _mm256_add_ps(_mm256_set1_ps(1.0f), XMMz);
-        XMMloss = _mm_add_pd(XMMloss, _mm_cvtps_pd(_mm_max_ps(
-                  _mm_set1_ps(0.0f), _mm256_castps256_ps128(XMMz))));
-        XMMz = _mm256_and_ps(_mm256_cmp_ps(XMMz, _mm256_set1_ps(0.0f),
-               _CMP_GE_OS), _mm256_set1_ps(-1.0f));
-    }
-}
-#else
-void L1_MFC::prepare_for_sg_update()
-{
-    calc_z(z, model.k, p, q);
-    if(N->r > 0)
-    {
-        loss += max(0.0f, 1-z);
-        error += z > 0? 1.0f: 0.0f;
-        z = z > 1? 0.0f: 1.0f;
-    }
-    else
-    {
-        loss += max(0.0f, 1+z);
-        error += z < 0? 1.0f: 0.0f;
-        z = z < -1? 0.0f: -1.0f;
-    }
-}
-#endif
-//--------------------------------------
-//------------One-class MF--------------
-//--------------------------------------
-
-class BPRSolver : public SolverBase
-{
-public:
-    BPRSolver(Scheduler &scheduler, vector<BlockBase*> &blocks,
-              mf_float *PG, mf_float *QG, mf_model &model, mf_parameter param,
-              bool &slow_only, bool is_column_oriented)
-        : SolverBase(scheduler, blocks, PG, QG, model, param, slow_only),
-                     is_column_oriented(is_column_oriented) {}
-
-protected:
-#if defined USESSE
-    static void calc_z(__m128 &XMMz, mf_int k,
-                       mf_float *p, mf_float *q, mf_float *w);
-    void arrange_block(__m128d &XMMloss, __m128d &XMMerror);
-    void prepare_for_sg_update(
-        __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-    void sg_update(mf_int d_begin, mf_int d_end, __m128 XMMz,
-                   __m128 XMMlambda_p1, __m128 XMMlambda_q1,
-                   __m128 XMMlambda_p2, __m128 XMMlamdba_q2,
-                   __m128 XMMeta, __m128 XMMrk);
-    void finalize(__m128d XMMloss, __m128d XMMerror);
-#elif defined USEAVX
-    static void calc_z(__m256 &XMMz, mf_int k,
-                       mf_float *p, mf_float *q, mf_float *w);
-    void arrange_block(__m128d &XMMloss, __m128d &XMMerror);
-    void prepare_for_sg_update(
-        __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror);
-    void sg_update(mf_int d_begin, mf_int d_end, __m256 XMMz,
-                   __m256 XMMlambda_p1, __m256 XMMlambda_q1,
-                   __m256 XMMlambda_p2, __m256 XMMlamdba_q2,
-                   __m256 XMMeta, __m256 XMMrk);
-    void finalize(__m128d XMMloss, __m128d XMMerror);
-#else
-    static void calc_z(mf_float &z, mf_int k,
-                       mf_float *p, mf_float *q, mf_float *w);
-    void arrange_block();
-    void prepare_for_sg_update();
-    void sg_update(mf_int d_begin, mf_int d_end, mf_float rk);
-    void finalize();
-#endif
-    void update() { ++pG; ++qG; ++wG; };
-    virtual void prepare_negative() = 0;
-
-    bool is_column_oriented;
-    mf_int bpr_bid;
-    mf_float *w;
-    mf_float *wG;
-};
-
-
-#if defined USESSE
-inline void BPRSolver::calc_z(
-    __m128 &XMMz, mf_int k, mf_float *p, mf_float *q, mf_float *w)
-{
-    XMMz = _mm_setzero_ps();
-    for(mf_int d = 0; d < k; d += 4)
-        XMMz = _mm_add_ps(XMMz, _mm_mul_ps(_mm_load_ps(p+d),
-               _mm_sub_ps(_mm_load_ps(q+d), _mm_load_ps(w+d))));
-    // Bit-wise representation of 177 is {1,0}+{1,1}+{0,0}+{0,1} from
-    // high-bit to low-bit, where "+" means concatenating two arrays.
-    __m128 XMMtmp = _mm_add_ps(XMMz, _mm_shuffle_ps(XMMz, XMMz, 177));
-    // Bit-wise representation of 78 is {0,1}+{0,0}+{1,1}+{1,0} from
-    // high-bit to low-bit, where "+" means concatenating two arrays.
-    XMMz = _mm_add_ps(XMMz, _mm_shuffle_ps(XMMtmp, XMMtmp, 78));
-}
-
-void BPRSolver::arrange_block(__m128d &XMMloss, __m128d &XMMerror)
-{
-    XMMloss = _mm_setzero_pd();
-    XMMerror = _mm_setzero_pd();
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-    bpr_bid = scheduler.get_bpr_job(bid, is_column_oriented);
-}
-
-void BPRSolver::finalize(__m128d XMMloss, __m128d XMMerror)
-{
-    _mm_store_sd(&loss, XMMloss);
-    _mm_store_sd(&error, XMMerror);
-    scheduler.put_job(bid, loss, error);
-    scheduler.put_bpr_job(bid, bpr_bid);
-}
-
-void BPRSolver::sg_update(mf_int d_begin, mf_int d_end, __m128 XMMz,
-                                 __m128 XMMlambda_p1, __m128 XMMlambda_q1,
-                                 __m128 XMMlambda_p2, __m128 XMMlambda_q2,
-                                 __m128 XMMeta, __m128 XMMrk)
-{
-    __m128 XMMpG = _mm_load1_ps(pG);
-    __m128 XMMqG = _mm_load1_ps(qG);
-    __m128 XMMwG = _mm_load1_ps(wG);
-    __m128 XMMeta_p = _mm_mul_ps(XMMeta, _mm_rsqrt_ps(XMMpG));
-    __m128 XMMeta_q = _mm_mul_ps(XMMeta, _mm_rsqrt_ps(XMMqG));
-    __m128 XMMeta_w = _mm_mul_ps(XMMeta, _mm_rsqrt_ps(XMMwG));
-
-    __m128 XMMpG1 = _mm_setzero_ps();
-    __m128 XMMqG1 = _mm_setzero_ps();
-    __m128 XMMwG1 = _mm_setzero_ps();
-
-    for(mf_int d = d_begin; d < d_end; d += 4)
-    {
-        __m128 XMMp = _mm_load_ps(p+d);
-        __m128 XMMq = _mm_load_ps(q+d);
-        __m128 XMMw = _mm_load_ps(w+d);
-
-        __m128 XMMpg = _mm_add_ps(_mm_mul_ps(XMMlambda_p2, XMMp),
-                       _mm_mul_ps(XMMz, _mm_sub_ps(XMMw, XMMq)));
-        __m128 XMMqg = _mm_sub_ps(_mm_mul_ps(XMMlambda_q2, XMMq),
-                       _mm_mul_ps(XMMz, XMMp));
-        __m128 XMMwg = _mm_add_ps(_mm_mul_ps(XMMlambda_q2, XMMw),
-                       _mm_mul_ps(XMMz, XMMp));
-
-        XMMpG1 = _mm_add_ps(XMMpG1, _mm_mul_ps(XMMpg, XMMpg));
-        XMMqG1 = _mm_add_ps(XMMqG1, _mm_mul_ps(XMMqg, XMMqg));
-        XMMwG1 = _mm_add_ps(XMMwG1, _mm_mul_ps(XMMwg, XMMwg));
-
-        XMMp = _mm_sub_ps(XMMp, _mm_mul_ps(XMMeta_p, XMMpg));
-        XMMq = _mm_sub_ps(XMMq, _mm_mul_ps(XMMeta_q, XMMqg));
-        XMMw = _mm_sub_ps(XMMw, _mm_mul_ps(XMMeta_w, XMMwg));
-
-        _mm_store_ps(p+d, XMMp);
-        _mm_store_ps(q+d, XMMq);
-        _mm_store_ps(w+d, XMMw);
-    }
-
-    mf_float tmp = 0;
-    _mm_store_ss(&tmp, XMMlambda_p1);
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMp = _mm_load_ps(p+d);
-            __m128 XMMflip = _mm_and_ps(_mm_cmple_ps(XMMp, _mm_set1_ps(0.0f)),
-                             _mm_set1_ps(-0.0f));
-            XMMp = _mm_xor_ps(XMMflip,
-                   _mm_max_ps(_mm_sub_ps(_mm_xor_ps(XMMp, XMMflip),
-                   _mm_mul_ps(XMMeta_p, XMMlambda_p1)), _mm_set1_ps(0.0f)));
-            _mm_store_ps(p+d, XMMp);
-        }
-    }
-
-    _mm_store_ss(&tmp, XMMlambda_q1);
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMq = _mm_load_ps(q+d);
-            __m128 XMMw = _mm_load_ps(w+d);
-            __m128 XMMflip = _mm_and_ps(_mm_cmple_ps(XMMq, _mm_set1_ps(0.0f)),
-                             _mm_set1_ps(-0.0f));
-            XMMq = _mm_xor_ps(XMMflip,
-                   _mm_max_ps(_mm_sub_ps(_mm_xor_ps(XMMq, XMMflip),
-                   _mm_mul_ps(XMMeta_q, XMMlambda_q1)), _mm_set1_ps(0.0f)));
-            _mm_store_ps(q+d, XMMq);
-
-
-            XMMflip = _mm_and_ps(_mm_cmple_ps(XMMw, _mm_set1_ps(0.0f)),
-                    _mm_set1_ps(-0.0f));
-            XMMw = _mm_xor_ps(XMMflip,
-                   _mm_max_ps(_mm_sub_ps(_mm_xor_ps(XMMw, XMMflip),
-                   _mm_mul_ps(XMMeta_w, XMMlambda_q1)), _mm_set1_ps(0.0f)));
-            _mm_store_ps(w+d, XMMw);
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 4)
-        {
-            __m128 XMMp = _mm_load_ps(p+d);
-            __m128 XMMq = _mm_load_ps(q+d);
-            __m128 XMMw = _mm_load_ps(w+d);
-            XMMp = _mm_max_ps(XMMp, _mm_set1_ps(0.0f));
-            XMMq = _mm_max_ps(XMMq, _mm_set1_ps(0.0f));
-            XMMw = _mm_max_ps(XMMw, _mm_set1_ps(0.0f));
-            _mm_store_ps(p+d, XMMp);
-            _mm_store_ps(q+d, XMMq);
-            _mm_store_ps(w+d, XMMw);
-        }
-    }
-
-    // Update learning rate of latent vector p. Squared derivatives along all
-    // latent dimensions will be computed above. Here their average will be
-    // added into the associated squared-gradient sum.
-    __m128 XMMtmp = _mm_add_ps(XMMpG1, _mm_movehl_ps(XMMpG1, XMMpG1));
-    XMMpG1 = _mm_add_ps(XMMpG1, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    XMMpG = _mm_add_ps(XMMpG, _mm_mul_ps(XMMpG1, XMMrk));
-    _mm_store_ss(pG, XMMpG);
-
-    // Similar code is used to update learning rate of latent vector q.
-    XMMtmp = _mm_add_ps(XMMqG1, _mm_movehl_ps(XMMqG1, XMMqG1));
-    XMMqG1 = _mm_add_ps(XMMqG1, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    XMMqG = _mm_add_ps(XMMqG, _mm_mul_ps(XMMqG1, XMMrk));
-    _mm_store_ss(qG, XMMqG);
-
-    // Similar code is used to update learning rate of latent vector w.
-    XMMtmp = _mm_add_ps(XMMwG1, _mm_movehl_ps(XMMwG1, XMMwG1));
-    XMMwG1 = _mm_add_ps(XMMwG1, _mm_shuffle_ps(XMMtmp, XMMtmp, 1));
-    XMMwG = _mm_add_ps(XMMwG, _mm_mul_ps(XMMwG1, XMMrk));
-    _mm_store_ss(wG, XMMwG);
-}
-
-void BPRSolver::prepare_for_sg_update(
-    __m128 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    prepare_negative();
-    calc_z(XMMz, model.k, p, q, w);
-    _mm_store_ss(&z, XMMz);
-    z = exp(-z);
-    XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1+z)));
-    XMMerror = XMMloss;
-    XMMz = _mm_set1_ps(z/(1+z));
-}
-#elif defined USEAVX
-inline void BPRSolver::calc_z(
-    __m256 &XMMz, mf_int k, mf_float *p, mf_float *q, mf_float *w)
-{
-    XMMz = _mm256_setzero_ps();
-    for(mf_int d = 0; d < k; d += 8)
-        XMMz = _mm256_add_ps(XMMz, _mm256_mul_ps(
-               _mm256_load_ps(p+d), _mm256_sub_ps(
-               _mm256_load_ps(q+d), _mm256_load_ps(w+d))));
-    XMMz = _mm256_add_ps(XMMz, _mm256_permute2f128_ps(XMMz, XMMz, 0x1));
-    XMMz = _mm256_hadd_ps(XMMz, XMMz);
-    XMMz = _mm256_hadd_ps(XMMz, XMMz);
-}
-
-void BPRSolver::arrange_block(__m128d &XMMloss, __m128d &XMMerror)
-{
-    XMMloss = _mm_setzero_pd();
-    XMMerror = _mm_setzero_pd();
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-    bpr_bid = scheduler.get_bpr_job(bid, is_column_oriented);
-}
-
-void BPRSolver::finalize(__m128d XMMloss, __m128d XMMerror)
-{
-    _mm_store_sd(&loss, XMMloss);
-    _mm_store_sd(&error, XMMerror);
-    scheduler.put_job(bid, loss, error);
-    scheduler.put_bpr_job(bid, bpr_bid);
-}
-
-void BPRSolver::sg_update(mf_int d_begin, mf_int d_end, __m256 XMMz,
-                                 __m256 XMMlambda_p1, __m256 XMMlambda_q1,
-                                 __m256 XMMlambda_p2, __m256 XMMlambda_q2,
-                                 __m256 XMMeta, __m256 XMMrk)
-{
-    __m256 XMMpG = _mm256_broadcast_ss(pG);
-    __m256 XMMqG = _mm256_broadcast_ss(qG);
-    __m256 XMMwG = _mm256_broadcast_ss(wG);
-    __m256 XMMeta_p =
-        _mm256_mul_ps(XMMeta, _mm256_rsqrt_ps(XMMpG));
-    __m256 XMMeta_q =
-        _mm256_mul_ps(XMMeta, _mm256_rsqrt_ps(XMMqG));
-    __m256 XMMeta_w =
-        _mm256_mul_ps(XMMeta, _mm256_rsqrt_ps(XMMwG));
-
-    __m256 XMMpG1 = _mm256_setzero_ps();
-    __m256 XMMqG1 = _mm256_setzero_ps();
-    __m256 XMMwG1 = _mm256_setzero_ps();
-
-    for(mf_int d = d_begin; d < d_end; d += 8)
-    {
-        __m256 XMMp = _mm256_load_ps(p+d);
-        __m256 XMMq = _mm256_load_ps(q+d);
-        __m256 XMMw = _mm256_load_ps(w+d);
-        __m256 XMMpg = _mm256_add_ps(_mm256_mul_ps(XMMlambda_p2, XMMp),
-                       _mm256_mul_ps(XMMz, _mm256_sub_ps(XMMw, XMMq)));
-        __m256 XMMqg = _mm256_sub_ps(_mm256_mul_ps(XMMlambda_q2, XMMq),
-                       _mm256_mul_ps(XMMz, XMMp));
-        __m256 XMMwg = _mm256_add_ps(_mm256_mul_ps(XMMlambda_q2, XMMw),
-                       _mm256_mul_ps(XMMz, XMMp));
-
-        XMMpG1 = _mm256_add_ps(XMMpG1, _mm256_mul_ps(XMMpg, XMMpg));
-        XMMqG1 = _mm256_add_ps(XMMqG1, _mm256_mul_ps(XMMqg, XMMqg));
-        XMMwG1 = _mm256_add_ps(XMMwG1, _mm256_mul_ps(XMMwg, XMMwg));
-
-        XMMp = _mm256_sub_ps(XMMp, _mm256_mul_ps(XMMeta_p, XMMpg));
-        XMMq = _mm256_sub_ps(XMMq, _mm256_mul_ps(XMMeta_q, XMMqg));
-        XMMw = _mm256_sub_ps(XMMw, _mm256_mul_ps(XMMeta_w, XMMwg));
-
-        _mm256_store_ps(p+d, XMMp);
-        _mm256_store_ps(q+d, XMMq);
-        _mm256_store_ps(w+d, XMMw);
-    }
-
-    mf_float tmp = 0;
-    _mm_store_ss(&tmp, _mm256_castps256_ps128(XMMlambda_p1));
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMp = _mm256_load_ps(p+d);
-            __m256 XMMflip =
-                _mm256_and_ps(
-                _mm256_cmp_ps(XMMp, _mm256_set1_ps(0.0f), _CMP_LE_OS),
-                _mm256_set1_ps(-0.0f));
-            XMMp = _mm256_xor_ps(XMMflip,
-                   _mm256_max_ps(_mm256_sub_ps(_mm256_xor_ps(XMMp, XMMflip),
-                   _mm256_mul_ps(XMMeta_p, XMMlambda_p1)),
-                   _mm256_set1_ps(0.0f)));
-            _mm256_store_ps(p+d, XMMp);
-        }
-    }
-
-    _mm_store_ss(&tmp, _mm256_castps256_ps128(XMMlambda_q1));
-    if(tmp > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMq = _mm256_load_ps(q+d);
-            __m256 XMMw = _mm256_load_ps(w+d);
-            __m256 XMMflip;
-
-            XMMflip = _mm256_and_ps(
-                      _mm256_cmp_ps(XMMq, _mm256_set1_ps(0.0f), _CMP_LE_OS),
-                      _mm256_set1_ps(-0.0f));
-            XMMq = _mm256_xor_ps(XMMflip,
-                   _mm256_max_ps(_mm256_sub_ps(_mm256_xor_ps(XMMq, XMMflip),
-                   _mm256_mul_ps(XMMeta_q, XMMlambda_q1)),
-                   _mm256_set1_ps(0.0f)));
-            _mm256_store_ps(q+d, XMMq);
-
-
-            XMMflip = _mm256_and_ps(
-                      _mm256_cmp_ps(XMMw, _mm256_set1_ps(0.0f), _CMP_LE_OS),
-                      _mm256_set1_ps(-0.0f));
-            XMMw = _mm256_xor_ps(XMMflip,
-                   _mm256_max_ps(_mm256_sub_ps(_mm256_xor_ps(XMMw, XMMflip),
-                   _mm256_mul_ps(XMMeta_w, XMMlambda_q1)),
-                   _mm256_set1_ps(0.0f)));
-            _mm256_store_ps(w+d, XMMw);
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; d += 8)
-        {
-            __m256 XMMp = _mm256_load_ps(p+d);
-            __m256 XMMq = _mm256_load_ps(q+d);
-            __m256 XMMw = _mm256_load_ps(w+d);
-            XMMp = _mm256_max_ps(XMMp, _mm256_set1_ps(0.0f));
-            XMMq = _mm256_max_ps(XMMq, _mm256_set1_ps(0.0f));
-            XMMw = _mm256_max_ps(XMMw, _mm256_set1_ps(0.0f));
-            _mm256_store_ps(p+d, XMMp);
-            _mm256_store_ps(q+d, XMMq);
-            _mm256_store_ps(w+d, XMMw);
-        }
-    }
-
-    XMMpG1 = _mm256_add_ps(XMMpG1,
-             _mm256_permute2f128_ps(XMMpG1, XMMpG1, 0x1));
-    XMMpG1 = _mm256_hadd_ps(XMMpG1, XMMpG1);
-    XMMpG1 = _mm256_hadd_ps(XMMpG1, XMMpG1);
-
-    XMMqG1 = _mm256_add_ps(XMMqG1,
-             _mm256_permute2f128_ps(XMMqG1, XMMqG1, 0x1));
-    XMMqG1 = _mm256_hadd_ps(XMMqG1, XMMqG1);
-    XMMqG1 = _mm256_hadd_ps(XMMqG1, XMMqG1);
-
-    XMMwG1 = _mm256_add_ps(XMMwG1,
-             _mm256_permute2f128_ps(XMMwG1, XMMwG1, 0x1));
-    XMMwG1 = _mm256_hadd_ps(XMMwG1, XMMwG1);
-    XMMwG1 = _mm256_hadd_ps(XMMwG1, XMMwG1);
-
-    XMMpG = _mm256_add_ps(XMMpG, _mm256_mul_ps(XMMpG1, XMMrk));
-    XMMqG = _mm256_add_ps(XMMqG, _mm256_mul_ps(XMMqG1, XMMrk));
-    XMMwG = _mm256_add_ps(XMMwG, _mm256_mul_ps(XMMwG1, XMMrk));
-
-    _mm_store_ss(pG, _mm256_castps256_ps128(XMMpG));
-    _mm_store_ss(qG, _mm256_castps256_ps128(XMMqG));
-    _mm_store_ss(wG, _mm256_castps256_ps128(XMMwG));
-}
-
-void BPRSolver::prepare_for_sg_update(
-    __m256 &XMMz, __m128d &XMMloss, __m128d &XMMerror)
-{
-    prepare_negative();
-    calc_z(XMMz, model.k, p, q, w);
-    _mm_store_ss(&z, _mm256_castps256_ps128(XMMz));
-    z = exp(-z);
-    XMMloss = _mm_add_pd(XMMloss, _mm_set1_pd(log(1+z)));
-    XMMerror = XMMloss;
-    XMMz = _mm256_set1_ps(z/(1+z));
-}
-#else
-inline void BPRSolver::calc_z(
-    mf_float &z, mf_int k, mf_float *p, mf_float *q, mf_float *w)
-{
-    z = 0;
-    for(mf_int d = 0; d < k; ++d)
-        z += p[d]*(q[d]-w[d]);
-}
-
-void BPRSolver::arrange_block()
-{
-    loss = 0.0;
-    error = 0.0;
-    bid = scheduler.get_job();
-    block = blocks[bid];
-    block->reload();
-    bpr_bid = scheduler.get_bpr_job(bid, is_column_oriented);
-}
-
-void BPRSolver::finalize()
-{
-    scheduler.put_job(bid, loss, error);
-    scheduler.put_bpr_job(bid, bpr_bid);
-}
-
-void BPRSolver::sg_update(mf_int d_begin, mf_int d_end, mf_float rk)
-{
-    mf_float eta_p = param.eta*qrsqrt(*pG);
-    mf_float eta_q = param.eta*qrsqrt(*qG);
-    mf_float eta_w = param.eta*qrsqrt(*wG);
-
-    mf_float pG1 = 0;
-    mf_float qG1 = 0;
-    mf_float wG1 = 0;
-
-    for(mf_int d = d_begin; d < d_end; ++d)
-    {
-        mf_float gp = z*(w[d]-q[d]) + lambda_p2*p[d];
-        mf_float gq = -z*p[d] + lambda_q2*q[d];
-        mf_float gw = z*p[d] + lambda_q2*w[d];
-
-        pG1 += gp*gp;
-        qG1 += gq*gq;
-        wG1 += gw*gw;
-
-        p[d] -= eta_p*gp;
-        q[d] -= eta_q*gq;
-        w[d] -= eta_w*gw;
-    }
-
-    if(lambda_p1 > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            mf_float p1 = max(abs(p[d])-lambda_p1*eta_p, 0.0f);
-            p[d] = p[d] >= 0? p1: -p1;
-        }
-    }
-
-    if(lambda_q1 > 0)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            mf_float q1 = max(abs(w[d])-lambda_q1*eta_w, 0.0f);
-            w[d] = w[d] >= 0? q1: -q1;
-            q1 = max(abs(q[d])-lambda_q1*eta_q, 0.0f);
-            q[d] = q[d] >= 0? q1: -q1;
-        }
-    }
-
-    if(param.do_nmf)
-    {
-        for(mf_int d = d_begin; d < d_end; ++d)
-        {
-            p[d] = max(p[d], (mf_float)0.0);
-            q[d] = max(q[d], (mf_float)0.0);
-            w[d] = max(w[d], (mf_float)0.0);
-        }
-    }
-
-    *pG += pG1*rk;
-    *qG += qG1*rk;
-    *wG += wG1*rk;
-}
-
-void BPRSolver::prepare_for_sg_update()
-{
-    prepare_negative();
-    calc_z(z, model.k, p, q, w);
-    z = exp(-z);
-    loss += log(1+z);
-    error = loss;
-    z = z/(1+z);
-}
-#endif
-
-class COL_BPR_MFOC : public BPRSolver
-{
-public:
-    COL_BPR_MFOC(Scheduler &scheduler, vector<BlockBase*> &blocks,
-                 mf_float *PG, mf_float *QG, mf_model &model,
-                 mf_parameter param, bool &slow_only,
-                 bool is_column_oriented=true)
-        : BPRSolver(scheduler, blocks, PG, QG, model, param,
-                    slow_only, is_column_oriented) {}
-protected:
-#if defined USESSE
-    void load_fixed_variables(
-        __m128 &XMMlambda_p1, __m128 &XMMlambda_q1,
-        __m128 &XMMlambda_p2, __m128 &XMMlabmda_q2,
-        __m128 &XMMeta, __m128 &XMMrk_slow,
-        __m128 &XMMrk_fast);
-#elif defined USEAVX
-    void load_fixed_variables(
-        __m256 &XMMlambda_p1, __m256 &XMMlambda_q1,
-        __m256 &XMMlambda_p2, __m256 &XMMlabmda_q2,
-        __m256 &XMMeta, __m256 &XMMrk_slow,
-        __m256 &XMMrk_fast);
-#else
-    void load_fixed_variables();
-#endif
-    void prepare_negative();
-};
-
-void COL_BPR_MFOC::prepare_negative()
-{
-    mf_int negative = scheduler.get_negative(bid, bpr_bid, model.m, model.n,
-                                             is_column_oriented);
-    w = model.P + negative*model.k;
-    wG = PG + negative*2;
-    swap(p, q);
-    swap(pG, qG);
-}
-
-#if defined USESSE
-void COL_BPR_MFOC::load_fixed_variables(
-    __m128 &XMMlambda_p1, __m128 &XMMlambda_q1,
-    __m128 &XMMlambda_p2, __m128 &XMMlambda_q2,
-    __m128 &XMMeta, __m128 &XMMrk_slow,
-    __m128 &XMMrk_fast)
-{
-    XMMlambda_p1 = _mm_set1_ps(param.lambda_q1);
-    XMMlambda_q1 = _mm_set1_ps(param.lambda_p1);
-    XMMlambda_p2 = _mm_set1_ps(param.lambda_q2);
-    XMMlambda_q2 = _mm_set1_ps(param.lambda_p2);
-    XMMeta = _mm_set1_ps(param.eta);
-    XMMrk_slow = _mm_set1_ps((mf_float)1.0/kALIGN);
-    XMMrk_fast = _mm_set1_ps((mf_float)1.0/(model.k-kALIGN));
-}
-#elif defined USEAVX
-void COL_BPR_MFOC::load_fixed_variables(
-    __m256 &XMMlambda_p1, __m256 &XMMlambda_q1,
-    __m256 &XMMlambda_p2, __m256 &XMMlambda_q2,
-    __m256 &XMMeta, __m256 &XMMrk_slow,
-    __m256 &XMMrk_fast)
-{
-    XMMlambda_p1 = _mm256_set1_ps(param.lambda_q1);
-    XMMlambda_q1 = _mm256_set1_ps(param.lambda_p1);
-    XMMlambda_p2 = _mm256_set1_ps(param.lambda_q2);
-    XMMlambda_q2 = _mm256_set1_ps(param.lambda_p2);
-    XMMeta = _mm256_set1_ps(param.eta);
-    XMMrk_slow = _mm256_set1_ps((mf_float)1.0/kALIGN);
-    XMMrk_fast = _mm256_set1_ps((mf_float)1.0/(model.k-kALIGN));
-}
-#else
-void COL_BPR_MFOC::load_fixed_variables()
-{
-    lambda_p1 = param.lambda_q1;
-    lambda_q1 = param.lambda_p1;
-    lambda_p2 = param.lambda_q2;
-    lambda_q2 = param.lambda_p2;
-    rk_slow = (mf_float)1.0/kALIGN;
-    rk_fast = (mf_float)1.0/(model.k-kALIGN);
-}
-#endif
-
-class ROW_BPR_MFOC : public BPRSolver
-{
-public:
-    ROW_BPR_MFOC(Scheduler &scheduler, vector<BlockBase*> &blocks,
-                 mf_float *PG, mf_float *QG, mf_model &model,
-                 mf_parameter param, bool &slow_only,
-                 bool is_column_oriented = false)
-        : BPRSolver(scheduler, blocks, PG, QG, model, param,
-                    slow_only, is_column_oriented) {}
-protected:
-    void prepare_negative();
-};
-
-void ROW_BPR_MFOC::prepare_negative()
-{
-    mf_int negative = scheduler.get_negative(bid, bpr_bid, model.m, model.n,
-                                             is_column_oriented);
-    w = model.Q + negative*model.k;
-    wG = QG + negative*2;
-}
-
-
-class SolverFactory
-{
-public:
-    static shared_ptr<SolverBase> get_solver(
-        Scheduler &scheduler,
-        vector<BlockBase*> &blocks,
-        mf_float *PG,
-        mf_float *QG,
-        mf_model &model,
-        mf_parameter param,
-        bool &slow_only);
-};
-
-shared_ptr<SolverBase> SolverFactory::get_solver(
-    Scheduler &scheduler,
-    vector<BlockBase*> &blocks,
-    mf_float *PG,
-    mf_float *QG,
-    mf_model &model,
-    mf_parameter param,
-    bool &slow_only)
-{
-    shared_ptr<SolverBase> solver;
-
-    switch(param.fun)
-    {
-        case P_L2_MFR:
-            solver = shared_ptr<SolverBase>(new L2_MFR(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_L1_MFR:
-            solver = shared_ptr<SolverBase>(new L1_MFR(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_KL_MFR:
-            solver = shared_ptr<SolverBase>(new KL_MFR(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_LR_MFC:
-            solver = shared_ptr<SolverBase>(new LR_MFC(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_L2_MFC:
-            solver = shared_ptr<SolverBase>(new L2_MFC(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_L1_MFC:
-            solver = shared_ptr<SolverBase>(new L1_MFC(scheduler, blocks,
-                        PG, QG, model, param, slow_only));
-            break;
-        case P_ROW_BPR_MFOC:
-            solver = shared_ptr<SolverBase>(new ROW_BPR_MFOC(scheduler,
-                        blocks, PG, QG, model, param, slow_only));
-            break;
-        case P_COL_BPR_MFOC:
-            solver = shared_ptr<SolverBase>(new COL_BPR_MFOC(scheduler,
-                        blocks, PG, QG, model, param, slow_only));
-            break;
-        default:
-            throw invalid_argument("unknown error function");
-    }
-    return solver;
-}
-
-void fpsg_core(
-    Utility &util,
-    Scheduler &sched,
-    mf_problem *tr,
-    mf_problem *va,
-    mf_parameter param,
-    mf_float scale,
-    vector<BlockBase*> &block_ptrs,
-    vector<mf_int> &omega_p,
-    vector<mf_int> &omega_q,
-    shared_ptr<mf_model> &model,
-    vector<mf_int> cv_blocks,
-    mf_double *cv_error)
-{
-#if defined USESSE || defined USEAVX
-    auto flush_zero_mode = _MM_GET_FLUSH_ZERO_MODE();
-    _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
-#endif
-    if(tr->nnz == 0)
-    {
-        cout << "warning: train on an empty training set" << endl;
-        return;
-    }
-
-    if(param.fun == P_L2_MFR ||
-       param.fun == P_L1_MFR ||
-       param.fun == P_KL_MFR)
-    {
-        switch(param.fun)
-        {
-            case P_L2_MFR:
-                param.lambda_p2 /= scale;
-                param.lambda_q2 /= scale;
-                param.lambda_p1 /= (mf_float)pow(scale, 1.5);
-                param.lambda_q1 /= (mf_float)pow(scale, 1.5);
-                break;
-            case P_L1_MFR:
-            case P_KL_MFR:
-                param.lambda_p1 /= sqrt(scale);
-                param.lambda_q1 /= sqrt(scale);
-                break;
-        }
-    }
-
-    if(!param.quiet)
-    {
-        cout.width(4);
-        cout << "iter";
-        cout.width(13);
-        cout << "tr_"+util.get_error_legend();
-        if(va->nnz != 0)
-        {
-            cout.width(13);
-            cout << "va_"+util.get_error_legend();
-        }
-        cout.width(13);
-        cout << "obj";
-        cout << "\n";
-    }
-
-    bool slow_only = param.lambda_p1 == 0 && param.lambda_q1 == 0? true: false;
-    vector<mf_float> PG(model->m*2, 1), QG(model->n*2, 1);
-
-    vector<shared_ptr<SolverBase>> solvers(param.nr_threads);
-    vector<thread> threads;
-    threads.reserve(param.nr_threads);
-    for(mf_int i = 0; i < param.nr_threads; ++i)
-    {
-        solvers[i] = SolverFactory::get_solver(sched, block_ptrs,
-                                               PG.data(), QG.data(),
-                                               *model, param, slow_only);
-        threads.emplace_back(&SolverBase::run, solvers[i].get());
-    }
-
-    for(mf_int iter = 0; iter < param.nr_iters; ++iter)
-    {
-        sched.wait_for_jobs_done();
-
-        if(!param.quiet)
-        {
-            mf_double reg = 0;
-            mf_double reg1 = util.calc_reg1(*model, param.lambda_p1,
-                             param.lambda_q1, omega_p, omega_q);
-            mf_double reg2 = util.calc_reg2(*model, param.lambda_p2,
-                             param.lambda_q2, omega_p, omega_q);
-            mf_double tr_loss = sched.get_loss();
-            mf_double tr_error = sched.get_error()/tr->nnz;
-
-            switch(param.fun)
-            {
-                case P_L2_MFR:
-                    reg = (reg1+reg2)*scale*scale;
-                    tr_loss *= scale*scale;
-                    tr_error = sqrt(tr_error*scale*scale);
-                    break;
-                case P_L1_MFR:
-                case P_KL_MFR:
-                    reg = (reg1+reg2)*scale;
-                    tr_loss *= scale;
-                    tr_error *= scale;
-                    break;
-                default:
-                    reg = reg1+reg2;
-                    break;
-            }
-
-            cout.width(4);
-            cout << iter;
-            cout.width(13);
-            cout << fixed << setprecision(4) << tr_error;
-            if(va->nnz != 0)
-            {
-                Block va_block(va->R, va->R+va->nnz);
-                vector<BlockBase*> va_blocks(1, &va_block);
-                vector<mf_int> va_block_ids(1, 0);
-                mf_double va_error =
-                    util.calc_error(va_blocks, va_block_ids, *model)/va->nnz;
-                switch(param.fun)
-                {
-                    case P_L2_MFR:
-                        va_error = sqrt(va_error*scale*scale);
-                        break;
-                    case P_L1_MFR:
-                    case P_KL_MFR:
-                        va_error *= scale;
-                        break;
-                }
-
-                cout.width(13);
-                cout << fixed << setprecision(4) << va_error;
-            }
-            cout.width(13);
-            cout << fixed << setprecision(4) << scientific << reg+tr_loss;
-            cout << "\n" << flush;
-        }
-
-        if(iter == 0)
-            slow_only = false;
-        if(iter == param.nr_iters - 1)
-            sched.terminate();
-        sched.resume();
-    }
-    
-    for(auto &thread : threads)
-        thread.join();
-
-    if(cv_error != nullptr && cv_blocks.size() > 0)
-    {
-        mf_long cv_count = 0;
-        for(auto block : cv_blocks)
-            cv_count += block_ptrs[block]->get_nnz();
-
-        *cv_error = util.calc_error(block_ptrs, cv_blocks, *model)/cv_count;
-
-        switch(param.fun)
-        {
-            case P_L2_MFR:
-                *cv_error = sqrt(*cv_error*scale*scale);
-                break;
-            case P_L1_MFR:
-            case P_KL_MFR:
-                *cv_error *= scale;
-                break;
-        }
-    }
-
-#if defined USESSE || defined USEAVX
-    _MM_SET_FLUSH_ZERO_MODE(flush_zero_mode);
-#endif
-}
-
-shared_ptr<mf_model> fpsg(
-    mf_problem const *tr_,
-    mf_problem const *va_,
-    mf_parameter param,
-    vector<mf_int> cv_blocks=vector<mf_int>(),
-    mf_double *cv_error=nullptr)
-{
-    shared_ptr<mf_model> model;
-try
-{
-    Utility util(param.fun, param.nr_threads);
-    Scheduler sched(param.nr_bins, param.nr_threads, cv_blocks);
-    shared_ptr<mf_problem> tr;
-    shared_ptr<mf_problem> va;
-    vector<Block> blocks(param.nr_bins*param.nr_bins);
-    vector<BlockBase*> block_ptrs(param.nr_bins*param.nr_bins);
-    vector<mf_node*> ptrs;
-    vector<mf_int> p_map;
-    vector<mf_int> q_map;
-    vector<mf_int> inv_p_map;
-    vector<mf_int> inv_q_map;
-    vector<mf_int> omega_p;
-    vector<mf_int> omega_q;
-    mf_float avg = 0;
-    mf_float std_dev = 0;
-    mf_float scale = 1;
-
-    if(param.copy_data)
-    {
-        tr = shared_ptr<mf_problem>(
-                Utility::copy_problem(tr_, true), deleter());
-        va = shared_ptr<mf_problem>(
-                Utility::copy_problem(va_, true), deleter());
-    }
-    else
-    {
-        tr = shared_ptr<mf_problem>(Utility::copy_problem(tr_, false));
-        va = shared_ptr<mf_problem>(Utility::copy_problem(va_, false));
-    }
-
-    util.collect_info(*tr, avg, std_dev);
-
-    if(param.fun == P_L2_MFR ||
-       param.fun == P_L1_MFR ||
-       param.fun == P_KL_MFR)
-        scale = max((mf_float)1e-4, std_dev);
-
-    p_map = Utility::gen_random_map(tr->m);
-    q_map = Utility::gen_random_map(tr->n);
-    inv_p_map = Utility::gen_inv_map(p_map);
-    inv_q_map = Utility::gen_inv_map(q_map);
-    omega_p = vector<mf_int>(tr->m, 0);
-    omega_q = vector<mf_int>(tr->n, 0);
-
-    util.shuffle_problem(*tr, p_map, q_map);
-    util.shuffle_problem(*va, p_map, q_map);
-    util.scale_problem(*tr, (mf_float)1.0/scale);
-    util.scale_problem(*va, (mf_float)1.0/scale);
-    ptrs = util.grid_problem(*tr, param.nr_bins, omega_p, omega_q, blocks);
-
-    model = shared_ptr<mf_model>(Utility::init_model(param.fun,
-                tr->m, tr->n, param.k, avg/scale, omega_p, omega_q),
-                [] (mf_model *ptr) { mf_destroy_model(&ptr); });
-
-    for(mf_int i = 0; i < (mf_long)blocks.size(); ++i)
-        block_ptrs[i] = &blocks[i];
-
-    fpsg_core(util, sched, tr.get(), va.get(), param, scale,
-              block_ptrs, omega_p, omega_q, model, cv_blocks, cv_error);
-
-    if(!param.copy_data)
-    {
-        util.scale_problem(*tr, scale);
-        util.scale_problem(*va, scale);
-        util.shuffle_problem(*tr, inv_p_map, inv_q_map);
-        util.shuffle_problem(*va, inv_p_map, inv_q_map);
-    }
-
-    util.scale_model(*model, scale);
-    Utility::shrink_model(*model, param.k);
-    Utility::shuffle_model(*model, inv_p_map, inv_q_map);
-}
-catch(exception const &e)
-{
-    cerr << e.what() << endl;
-    throw;
-}
-    return model;
-}
-
-shared_ptr<mf_model> fpsg_on_disk(
-    const string tr_path,
-    const string va_path,
-    mf_parameter param,
-    vector<mf_int> cv_blocks=vector<mf_int>(),
-    mf_double *cv_error=nullptr)
-{
-    shared_ptr<mf_model> model;
-try
-{
-    Utility util(param.fun, param.nr_threads);
-    Scheduler sched(param.nr_bins, param.nr_threads, cv_blocks);
-    mf_problem tr = {};
-    mf_problem va = read_problem(va_path.c_str());
-    vector<BlockOnDisk> blocks(param.nr_bins*param.nr_bins);
-    vector<BlockBase*> block_ptrs(param.nr_bins*param.nr_bins);
-    vector<mf_int> p_map;
-    vector<mf_int> q_map;
-    vector<mf_int> inv_p_map;
-    vector<mf_int> inv_q_map;
-    vector<mf_int> omega_p;
-    vector<mf_int> omega_q;
-    mf_float avg = 0;
-    mf_float std_dev = 0;
-    mf_float scale = 1;
-
-    util.collect_info_on_disk(tr_path, tr, avg, std_dev);
-
-    if(param.fun == P_L2_MFR ||
-       param.fun == P_L1_MFR ||
-       param.fun == P_KL_MFR)
-        scale = max((mf_float)1e-4, std_dev);
-
-    p_map = Utility::gen_random_map(tr.m);
-    q_map = Utility::gen_random_map(tr.n);
-    inv_p_map = Utility::gen_inv_map(p_map);
-    inv_q_map = Utility::gen_inv_map(q_map);
-    omega_p = vector<mf_int>(tr.m, 0);
-    omega_q = vector<mf_int>(tr.n, 0);
-
-    util.shuffle_problem(va, p_map, q_map);
-    util.scale_problem(va, (mf_float)1.0/scale);
-
-    util.grid_shuffle_scale_problem_on_disk(
-        tr.m, tr.n, param.nr_bins, scale, tr_path,
-        p_map, q_map, omega_p, omega_q, blocks);
-
-    model = shared_ptr<mf_model>(Utility::init_model(param.fun,
-                tr.m, tr.n, param.k, avg/scale, omega_p, omega_q),
-                [] (mf_model *ptr) { mf_destroy_model(&ptr); });
-
-    for(mf_int i = 0; i < (mf_long)blocks.size(); ++i)
-        block_ptrs[i] = &blocks[i];
-
-    fpsg_core(util, sched, &tr, &va, param, scale,
-              block_ptrs, omega_p, omega_q, model, cv_blocks, cv_error);
-
-    delete [] va.R;
-
-    util.scale_model(*model, scale);
-    Utility::shrink_model(*model, param.k);
-    Utility::shuffle_model(*model, inv_p_map, inv_q_map);
-}
-catch(exception const &e)
-{
-    cerr << e.what() << endl;
-    throw;
-}
-    return model;
-}
-
-// The function implements an efficient method to compute objective function
-// minimized by coordinate descent method.
-// 
-// \min_{P, Q} 0.5 * \sum_{(u,v)\in\Omega^+} (1-r_{u,v})^2  +
-//             0.5 * \alpha \sum_{(u,v)\not\in\Omega^+} (c-r_{u,v})^2 +
-//             0.5 * \lambda_p2 * ||P||_F^2 + 0.5 * \lambda_q2 * ||Q||_F^2
-// where
-//  1. (u,v) is a tuple of row index and column index,
-//  2. \Omega^+ a collections of (u,v) which specifies the locations of
-//     positive entries in the training matrix.
-//  3. r_{u,v} is the predicted rating at (u,v)
-//  4. \alpha is the weight of negative entries' loss.
-//  5. c is the desired value at every negative entries.
-//  6. ||P||_F is matrix P's Frobenius norm.
-//  7. \lambda_p2 is the regularization coefficient of P.
-//  
-//  Note that coordinate descent method's P and Q are the transpose
-//  counterparts of P and Q in stochastic gradient method. Let R denoates 
-//  the training matrix. For stochastic gradient method, we have R ~ P^TQ.
-//  For coordinate descent method, we have R ~ PQ^T.
-void calc_ccd_one_class_obj(const mf_int nr_threads,
-        const mf_float alpha, const mf_float c,
-        const mf_int m, const mf_int n, const mf_int d,
-        const mf_float lambda_p2, const mf_float lambda_q2,
-        const mf_float *P, const mf_float *Q,
-        shared_ptr<const mf_problem> data,
-        /*output*/ mf_double &obj,
-        /*output*/ mf_double &positive_loss,
-        /*output*/ mf_double &negative_loss,
-        /*output*/ mf_double &reg)
-{
-    // Declare regularization term of P.
-    mf_double p_square_norm = 0.0;
-    // Reduce P along column axis, which is the sum of rows in P. 
-    vector<mf_double> all_p_sum(d, 0.0);
-    // Compute square of Frobenius norm on P and sum of all rows in P.
-    for(mf_int k = 0; k < d; ++k)
-    {
-        // Declare a temporal buffer of all_p_sum[k] for using OpenMP.
-        mf_double all_p_sum_k = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:p_square_norm,all_p_sum_k)
-#endif
-        for(mf_int u = 0; u < m; ++u)
-        {
-            const mf_float &p_ku = P[u + k * m];
-            p_square_norm += p_ku * p_ku;
-            all_p_sum_k += p_ku;
-        }
-        all_p_sum[k] = all_p_sum_k;
-    }
-
-    // Declare regularization term of Q
-    mf_double q_square_norm = 0.0;
-    // Reduce Q along column axis, whihc is the sum of rows in Q.
-    vector<mf_double> all_q_sum(d, 0.0);
-    // Compute square of Frobenius norm on Q and sum of all elements in Q
-    for(mf_int k = 0; k < d; ++k)
-    {
-        // Declare a temporal buffer of all_p_sum[k] for using OpenMP.
-        mf_double all_q_sum_k = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:q_square_norm,all_q_sum_k)
-#endif
-        for(mf_int v = 0; v < n; ++v)
-        {
-            const mf_float &q_kv = Q[v + k * n];
-            q_square_norm += q_kv * q_kv;
-            all_q_sum_k += q_kv;
-        }
-        all_q_sum[k] = all_q_sum_k;
-    }
-
-    // PTP = P^T * P, where P^T is the transpose of P. Note that P is a m-by-d
-    // matrix and PTP is a d-by-d matrix.
-    vector<mf_double> PTP(d * d, 0.0);
-    // QTQ = Q^T * P, a d-by-d matrix.
-    vector<mf_double> QTQ(d * d, 0.0);
-    // We calculate PTP and QTQ because they are needed in the computation of
-    // negative entries' loss function.
-    for(mf_int k1 = 0; k1 < d; ++k1)
-    {
-        for(mf_int k2 = 0; k2 < d; ++k2)
-        {
-            // Inner product of the k1 and k2 columns in P, a m-by-d matrix.
-            mf_double p_k1_p_k2_inner_product = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:p_k1_p_k2_inner_product)
-#endif
-            for(mf_int u = 0; u < m; ++u)
-                p_k1_p_k2_inner_product += P[u + k1 * m] * P[u + k2 * m];
-            PTP[k1 * d + k2] = p_k1_p_k2_inner_product;
-
-            // Inner product of the k1 and k2 columns in Q, a n-by-d matrix.
-            mf_double q_k1_q_k2_inner_product = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:q_k1_q_k2_inner_product)
-#endif
-            for(mf_int v = 0; v < n; ++v)
-                q_k1_q_k2_inner_product += Q[v + k1 * n] * Q[v + k2 * n];
-            QTQ[k1 * d + k2] = q_k1_q_k2_inner_product;
-        }
-    }
-
-    // Initialize loss function value of positive matrix entries.
-    // It consists two parts. The first part is the true prediction error
-    // while the second part is only used for implementing faster algorithm.
-    mf_double positive_loss1 = 0.0;
-    mf_double positive_loss2 = 0.0;
-    // Scan through positive matrix entries to compute their loss values.
-    // Notice that we assume that positive entries' values are all one.
-#if defined USEOMP
-#pragma omp parallel for num_threads(nr_threads) schedule(static) reduction(+:positive_loss1,positive_loss2)
-#endif
-    for(mf_long i = 0; i < data->nnz; ++i)
-    {
-        const mf_double &r = data->R[i].r;
-        positive_loss1 += (1.0 - r) * (1.0 - r);
-        positive_loss2 -= alpha * (c - r) * (c - r); 
-    }
-    positive_loss1 *= 0.5;
-    positive_loss2 *= 0.5;
-
-    // Declare loss terms related to negative matrix entries.
-    mf_double negative_loss1 = c * c * m * n;
-    mf_double negative_loss2 = 0.0;
-    mf_double negative_loss3 = 0.0;
-    // Compute loss terms.
-    for(mf_int k1 = 0; k1 < d; ++k1)
-    {
-        negative_loss2 += all_p_sum[k1] * all_q_sum[k1];
-        for(mf_int k2 = 0; k2 < d; ++k2)
-            negative_loss3 += PTP[k1 + k2 * d] * QTQ[k2 + k1 * d];
-    }
-    // Compute the loss function of negative matrix entries.
-    mf_double negative_loss4 = 0.5 * alpha *
-        (negative_loss1 - 2 * c * negative_loss2 + negative_loss3);
-
-    // Assign results to output variables.
-    reg = 0.5 * lambda_p2 * p_square_norm + 0.5 * lambda_q2 * q_square_norm;
-
-    // The function minimized by coordinate descent method.
-    obj = positive_loss1 + positive_loss2 + negative_loss4 + reg;
-
-    // Sume of squared error over positive matrix entries (i.e., those mf_node's
-    // in data).
-    positive_loss = positive_loss1;
-
-    // Sume of squared error over negative matrix entries (i.e., those mf_node's
-    // in data). The value negative_loss4 contains the squared errors by
-    // considering positive entries as negative entries, so positive_loss2 is
-    // added to compensate that.
-    negative_loss = negative_loss4 + positive_loss2;
-}
-
-void ccd_one_class_core(
-    const Utility &util,
-    shared_ptr<const mf_problem> tr_csr,
-    shared_ptr<const mf_problem> tr_csc,
-    shared_ptr<const mf_problem> va,
-    const mf_parameter param,
-    const vector<mf_node*> &ptrs_u,
-    const vector<mf_node*> &ptrs_v,
-    /*output*/ shared_ptr<mf_model> &model)
-{
-    // Check problems stored in CSR and CSC formats
-    if(tr_csr == nullptr) throw invalid_argument("CSR problem pointer is null.");
-    if(tr_csc == nullptr) throw invalid_argument("CSC problem pointer is null.");
-
-    if(tr_csr->m != tr_csc->m)
-        throw logic_error(
-                "Row counts must be identical in CSR and CSC formats: " +
-                to_string(tr_csr->m) + " != " + to_string(tr_csc->m));
-    const mf_int m = tr_csr->m;
-
-    if(tr_csr->n != tr_csc->n)
-        throw logic_error(
-                "Column counts must be identical in CSR and CSC formats: " +
-                to_string(tr_csr->n) + " != " + to_string(tr_csc->n));
-    const mf_int n = tr_csr->n;
-
-    if(tr_csc->nnz != tr_csc->nnz)
-        throw logic_error(
-                "Numbers of data points must be identical in CSR and CSC formats: " +
-                to_string(tr_csr->nnz) + " != " + to_string(tr_csc->nnz));
-    const mf_long nnz = tr_csr->nnz;
-
-    // Check formulation parameters
-    if(param.k <= 0)
-        throw invalid_argument(
-                "Latent dimension must be positive but got " +
-                to_string(param.k));
-    const mf_int d = param.k;
-
-    if(param.lambda_p1 != 0)
-        throw invalid_argument(
-                "P's L1-regularization coefficient must be zero but got " +
-                to_string(param.lambda_p1));
-    if(param.lambda_q1 != 0)
-        throw invalid_argument(
-                "Q's L1-regularization coefficient must be zero but got " +
-                to_string(param.lambda_q1));
-
-    if(param.lambda_p2 <= 0)
-        throw invalid_argument(
-                "P's L2-regularization coefficient must be positive but got " +
-                to_string(param.lambda_p2));
-    if(param.lambda_q2 <= 0)
-        throw invalid_argument(
-                "Q's L2-regularization coefficient must be positive but got " +
-                to_string(param.lambda_q2));
-
-    // REVIEW: It is not difficult to support non-negative matrix factorization
-    // for coordinate descent method; we just need to project the updated value
-    // back to the feasible region by using max(0, new_value) right after each
-    // Newton step. LIBMF hasn't support it only because we don't see actual
-    // users.
-    if(param.do_nmf)
-        throw invalid_argument(
-                "Coordinate descent does not support non-negative constraint"); 
-
-
-    // Check some resources prepared internally
-    if(ptrs_u.size() != (size_t)m + 1)
-        throw invalid_argument("Number of row pointer must be " +
-                to_string(m + 1) + " but got " + to_string(ptrs_u.size()));
-    if(ptrs_v.size() != (size_t)n + 1)
-        throw invalid_argument("Number of column pointer must be " +
-                to_string(n + 1) + " but got " + to_string(ptrs_v.size()));
-
-    // Some constants of the formulation.
-    // alpha: coefficient of negative part
-    // c: the desired prediction values of unobserved ratings
-    // lambda_p2: regularization coefficient of P's L2-norm
-    // lambda_q2: regularization coefficient of P's Q2-norm
-    const mf_float alpha = param.alpha;
-    const mf_float c = param.c;
-    const mf_float lambda_p2 = param.lambda_p2;
-    const mf_float lambda_q2 = param.lambda_q2;
-
-    // Initialize P and Q. Note that \bar{q}_{kv} is Q[k*n+v]
-    // and \bar{p}_{ku} is P[k*m+u]. One may notice that P and
-    // Q here are actually the transposes of P and Q in FPSG.
-    mf_float *P = model->P;
-    mf_float *Q = model->Q;
-
-    // Cache the prediction values on positive matrix entries.
-    // Given that P=zero and Q=random initialized in 
-    // Utility::init_model(mf_int m, mf_int n, mf_int k),
-    // all predictions are zeros.
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-    for(mf_long i = 0; i < nnz; ++i)
-    {
-        tr_csr->R[i].r = 0.0;
-        tr_csc->R[i].r = 0.0;
-    }
-
-    // If the model is not initialized by
-    // Utility::init_model(mf_int m, mf_int n, mf_int k),
-    // please use the following initialization code to compute
-    // and cache all prediction values on positive entries.
-    /*
-    for(mf_long i = 0; i < nnz; ++i)
-    {
-        mf_node &node = tr_csr->R[i];
-        node.r = 0;
-        for(mf_int k = 0; k < d; ++k)
-            node.r += P[node.u + k * m]*Q[node.v + k * n];
-    }
-    for(mf_long i = 0; i < nnz; ++i)
-    {
-        mf_node &node = tr_csc->R[i];
-        node.r = 0;
-        for(mf_int k = 0; k < d; ++k)
-            node.r += P[node.u + k * m]*Q[node.v + k * n];
-    }
-    */
-
-    if(!param.quiet)
-    {
-        cout.width(4);
-        cout << "iter";
-        cout.width(13);
-        cout << "tr_"+util.get_error_legend();
-        cout.width(14);
-        cout << "tr_"+util.get_error_legend() << "+";
-        cout.width(14);
-        cout << "tr_"+util.get_error_legend() << "-";
-        if(va->nnz != 0)
-        {
-            cout.width(13);
-            cout << "va_"+util.get_error_legend();
-            cout.width(14);
-            cout << "va_"+util.get_error_legend() << "+";
-            cout.width(14);
-            cout << "va_"+util.get_error_legend() << "-";
-        }
-        cout.width(13);
-        cout << "obj";
-        cout << "\n";
-    }
-
-    /////////////////////////////////////////////////////////////////
-    // Minimize the objective function via coordinate descent method
-    ////////////////////////////////////////////////////////////////
-    // Solve P and Q using coordinate descent.
-    // P = [\bar{p}_1, ..., \bar{p}_d] \in R^{m \times k}
-    // Q = [\bar{q}_1, ..., \bar{q}_d] \in R^{n \times k}
-    // Finally, the rating matrice R would be approximated via
-    // R ~ PQ^T \in R^{m \times n}
-    for(mf_int outer = 0; outer < param.nr_iters; ++outer)
-    {
-        // Update \bar{p}_k and \bar{q}_k. The basic idea is
-        // to replace \bar{p}_k and \bar{q}_k with a and b,
-        // and then minimizes the original objective function.
-        for(mf_int k = 0; k < d; ++k)
-        {
-            // Get the pointer to the first element of \bar{p}_k (and
-            // \bar{q}_k).
-            mf_float *P_k = P + m * k;
-            mf_float *Q_k = Q + n * k;
-
-            // Initialize a and b with the value they need to replace
-            // so that we can ensure improvement at each iteration.
-            vector<mf_float> a(P_k, P_k + m);
-            vector<mf_float> b(Q_k, Q_k + n);
-
-            for(mf_int inner = 0; inner < 3; ++inner)
-            {
-                ///////////////////////////////////////////////////////////////
-                // Update a:
-                //  1. Compute and cache constants
-                //  2. For each coordinate of a, calculate optimal update using
-                //     Newton method 
-                ///////////////////////////////////////////////////////////////
-
-                // Compute and cache constants
-                // \hat{b} = \sum_{v=1}^n \bar{b}_v
-                // \tilde{b} = \sum_{v=1}^n \bar{b}_v^2
-                mf_double b_hat = 0.0;
-                mf_double b_tilde = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static) reduction(+:b_hat,b_tilde)
-#endif
-                for(mf_int v = 0; v < n; ++v)
-                {
-                    const mf_double &b_v = b[v]; 
-                    b_hat += b_v;
-                    b_tilde += b_v * b_v;
-                }
-
-                // Compute and cache a constant vector
-                // s_k = \sum_{v=1}^n \bar{q}_{kv}b_v, k = 1, ..., d
-                vector<mf_double> s(d, 0.0); 
-                for(mf_int k1 = 0; k1 < d; ++k1)
-                {
-                    // Buffer variable for using OpenMP
-                    mf_double s_k1 = 0;
-                    const mf_float *Q_k1 = Q + k1 * n;
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static) reduction(+:s_k1)
-#endif
-                    for(mf_int v = 0; v < n; ++v)
-                        s_k1 += Q_k1[v] * b[v];
-                    s[k1] = s_k1;
-                }
-
-                // Solve a's sub-problem
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-                for(mf_int u = 0; u < m; ++u)
-                {
-                    ////////////////////////////////////////////////////////
-                    // Update a[u] via Newton method. Let g_u and h_u denote
-                    // the first-order and second-order derivatives w.r.t.
-                    // a[u]. The following code implements
-                    //  a[u] <-- a[u] - g_u/h_u
-                    ////////////////////////////////////////////////////////
-
-                    // Initialize temporal variables for calculating gradient and hessian.
-                    mf_double g_u_1 = 0.0;
-                    mf_double h_u_1 = 0.0;
-                    mf_double g_u_2 = 0.0;
-                    // Scan through specified entries at the u-th row
-                    for(const mf_node *ptr = ptrs_u[u]; ptr != ptrs_u[u+1]; ++ptr)
-                    {
-                        const mf_int &v = ptr->v;
-                        const mf_float &b_v = b[v];
-                        g_u_1 += b_v;
-                        h_u_1 += b_v * b_v;
-                        g_u_2 += (ptr->r - P_k[u] * Q_k[v] + a[u] * b_v) * b_v;
-                    }
-                    mf_double g_u_3 = -c * b_hat - P_k[u] * s[k] + a[u] * b_tilde;
-                    for(mf_int k1 = 0; k1 < d; ++k1)
-                        g_u_3 += P[m * k1 + u] * s[k1];
-                    mf_double g_u = -(1.0 - alpha * c) * g_u_1 + (1.0 - alpha) * g_u_2 + alpha * g_u_3 + lambda_p2 * a[u];
-                    mf_double h_u = (1.0 - alpha) * h_u_1 + alpha * b_tilde + lambda_p2;
-                    a[u] -= static_cast<mf_float>(g_u / h_u);
-                }
-
-                ///////////////////////////////////////////////////////////////
-                // Update b:
-                //  1. Compute and cache constants
-                //  2. For each coordinate of b, calculate optimal update using
-                //     Newton method 
-                ///////////////////////////////////////////////////////////////
-                // Compute and cache a_hat, a_tilde
-                // \hat{a} = \sum_{u=1}^m \bar{a}_u
-                // \tilde{a} = \sum_{u=1}^m \bar{a}_u^2
-                mf_double a_hat = 0.0;
-                mf_double a_tilde = 0.0;
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static) reduction(+:a_hat,a_tilde)
-#endif
-                for(mf_int u = 0; u < m; ++u)
-                {
-                    const mf_float &a_u = a[u];
-                    a_hat += a_u;
-                    a_tilde += a_u * a_u;
-                }
-
-                // Compute and cache t
-                // t_k = \sum_{u=1}^m \bar{a}_{ku}a_u, k = 1, ..., d
-                vector<mf_double> t(d, 0.0);
-                for(mf_int k1 = 0; k1 < d; ++k1)
-                {
-                    // Declare buffer variable for using OpenMP
-                    mf_double t_k1 = 0;
-                    const mf_float *P_k1 = P + k1 * m;
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static) reduction(+:t_k1)
-#endif
-                    for(mf_int u = 0; u < m; ++u)
-                        t_k1 += P_k1[u] * a[u];
-                    t[k1] = t_k1;
-                }
-
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-                for(mf_int v = 0; v < n; ++v)
-                {
-                    ////////////////////////////////////////////////////////
-                    // Update b[v] via Newton method. Let g_v and h_v denote
-                    // the first-order and second-order derivatives w.r.t.
-                    // b[v]. The following code implements
-                    //  b[v] <-- b[v] - g_v/h_v
-                    ////////////////////////////////////////////////////////
-
-                    // Initialize temporal variables for calculating gradient and hessian.
-                    mf_double g_v_1 = 0;
-                    mf_double g_v_2 = 0;
-                    mf_double h_v_1 = 0;
-                    // Scan through all positive entries at column v
-                    for(const mf_node *ptr = ptrs_v[v]; ptr != ptrs_v[v+1]; ++ptr)
-                    {
-                        const mf_int &u = ptr->u;
-                        const mf_float &a_u = a[u];
-                        g_v_1 += a_u;
-                        h_v_1 += a_u * a_u;
-                        g_v_2 += (ptr->r - P_k[u] * Q_k[v] + a_u * b[v]) * a_u;
-                    }
-                    mf_double g_v_3 = -c * a_hat - Q_k[v] * t[k] + b[v] * a_tilde;
-                    for(mf_int k1 = 0; k1 < d; ++k1)
-                        g_v_3 += Q[n * k1 + v] * t[k1];
-                    mf_double g_v = -(1.0 - alpha * c) * g_v_1 + (1.0 - alpha) * g_v_2 +
-                        alpha * g_v_3 + lambda_q2 * b[v];
-                    mf_double h_v = (1 - alpha) * h_v_1 + alpha * a_tilde + lambda_q2;
-                    b[v] -= static_cast<mf_float>(g_v / h_v);
-                }
-
-                ///////////////////////////////////////////////////////////////
-                // Update cached variables.
-                ///////////////////////////////////////////////////////////////
-                // Update prediction error in CSR format
-                // \bar{r}_{uv} <- \bar{r}_{uv} - \bar_{p}_{ku}*\bar_{q}_{kv} + a_u*b_v
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-                for(mf_long i = 0; i < tr_csr->nnz; ++i)
-                {
-                    // Update prediction values of positive entries in CSR
-                    mf_node *csr_ptr = tr_csr->R + i;
-                    const mf_int &u_csr = csr_ptr->u;
-                    const mf_int &v_csr = csr_ptr->v;
-                    csr_ptr->r += a[u_csr] * b[v_csr] - P_k[u_csr] * Q_k[v_csr];
-
-                    // Update prediction values of positive entries in CSC
-                    mf_node *csc_ptr = tr_csc->R + i;
-                    const mf_int &u_csc = csc_ptr->u;
-                    const mf_int &v_csc = csc_ptr->v;
-                    csc_ptr->r += a[u_csc] * b[v_csc] - P_k[u_csc] * Q_k[v_csc];
-                }
-
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-                // Update P_k and Q_k
-                for(mf_int u = 0; u < m; ++u)
-                    P_k[u] = a[u];
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-                for(mf_int v = 0; v < n; ++v)
-                    Q_k[v] = b[v];
-            }
-        }
-
-        // Skip the whole evaluation if nothing should be printed out.
-        if(param.quiet)
-            continue;
-
-        // Declare variable for storing objective value being minimized
-        // by the training procedure. Note that The objective value consists
-        // of two parts, loss function and regularization function.
-        mf_double obj = 0;
-        // Declare variables for storing loss function's value.
-        mf_double positive_loss = 0; // for positive entries in training matrix.
-        mf_double negative_loss = 0; // for negative entries in training matrix.
-        // Declare variable for storing regularization function's value.
-        mf_double reg = 0;
-
-        // Compute objective value, loss function value, and regularization
-        // function value
-        calc_ccd_one_class_obj(util.get_thread_number(), alpha, c, m, n, d,
-                lambda_p2, lambda_q2, P, Q, tr_csr,
-                obj, positive_loss, negative_loss, reg);
-
-        // Print number of outer iterations.
-        cout.width(4);
-        cout << outer;
-        cout.width(13);
-        cout << fixed << setprecision(4) << positive_loss + negative_loss;
-        cout.width(15);
-        cout << fixed << setprecision(4) << positive_loss;
-        cout.width(15);
-        cout << fixed << setprecision(4) << negative_loss;
-
-        if(va->nnz != 0)
-        {
-            // The following loop computes prediction scores on validation set.
-            // Because training scores is also maintained in coordinate descent
-            // framework, we didn't need to actively compute scores on training set.
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-            for(mf_long i = 0; i < va->nnz; ++i)
-            {
-                mf_node &node = va->R[i];
-                node.r = 0;
-                for(mf_int k = 0; k < d; ++k)
-                    node.r += P[node.u + k * m]*Q[node.v + k * n];
-            }
-
-            mf_double va_obj = 0;
-            mf_double va_positive_loss = 0;
-            mf_double va_negative_loss = 0;
-            mf_double va_reg = 0;
-
-            calc_ccd_one_class_obj(util.get_thread_number(), alpha, c, m, n, d,
-                    lambda_p2, lambda_q2, P, Q, va,
-                    va_obj, va_positive_loss, va_negative_loss, va_reg);
-
-            cout.width(13);
-            cout << fixed << setprecision(4) << va_positive_loss + va_negative_loss;
-            cout.width(15);
-            cout << fixed << setprecision(4) << va_positive_loss;
-            cout.width(15);
-            cout << fixed << setprecision(4) << va_negative_loss;
-        }
-
-        cout.width(13);
-        cout << fixed << setprecision(4) << scientific << obj;
-        cout << "\n" << flush;
-    }
-
-    // Transpose P and Q. Note that the format of P and Q here are different
-    // than that for mf_model.
-
-    mf_float *P_transpose = Utility::malloc_aligned_float((mf_long)m * d);
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-    for(mf_int u = 0; u < m; ++u)
-        for(mf_int k = 0; k < d; ++k)
-            P_transpose[k + u * d] = P[u + k * m];
-    Utility::free_aligned_float(P);
-    mf_float *Q_transpose = Utility::malloc_aligned_float((mf_long)n * d);
-#if defined USEOMP
-#pragma omp parallel for num_threads(util.get_thread_number()) schedule(static)
-#endif
-    for(mf_int v = 0; v < n; ++v)
-        for(mf_int k = 0; k < d; ++k)
-            Q_transpose[k + v * d] = Q[v + k * n];
-    Utility::free_aligned_float(Q);
-
-    // Set the passed-in model to the result learned from the given data
-    // model is null
-    model->m = m;
-    model->n = n;
-    model->k = d;
-    model->b = 0.0;
-    model->P = P_transpose;
-    model->Q = Q_transpose;
-}
-
-shared_ptr<mf_model> ccd_one_class(
-    mf_problem const *tr_,
-    mf_problem const *va_,
-    mf_parameter param)
-{
-    shared_ptr<mf_model> model;
-try
-{
-    Utility util(param.fun, param.nr_threads);
-    // Training matrix in compressed row format (sort nodes by user id)
-    shared_ptr<mf_problem> tr_csr;
-    // Training matrix in compressed column format (sort nodes by item id)
-    shared_ptr<mf_problem> tr_csc;
-    shared_ptr<mf_problem> va;
-    // In tr_csr->R, i-th row starting at row_ptrs[i] and eneding right before row_ptrs[i+1]
-    vector<mf_node*> ptrs_u(tr_->m + 1, nullptr);
-    // In tr_csv->R, i-th column starting at col_ptrs[i] and eneding right before col_ptrs[i+1]
-    vector<mf_node*> ptrs_v(tr_->n + 1, nullptr);
-
-    if(param.copy_data)
-    {
-        // Need a row-major and a column-major training formats
-        // Thus, two duplicates are made.
-        tr_csr = shared_ptr<mf_problem>(
-                Utility::copy_problem(tr_, true), deleter());
-        tr_csc = shared_ptr<mf_problem>(
-                Utility::copy_problem(tr_, true), deleter());
-        va = shared_ptr<mf_problem>(
-                Utility::copy_problem(va_, true), deleter());
-    }
-    else
-    {
-        // Need a row-major and a column-major training formats
-        // The original data is reused as row-major one so
-        // one duplicate for column-major one would be created.
-        tr_csr = shared_ptr<mf_problem>(Utility::copy_problem(tr_, false));
-        tr_csc = shared_ptr<mf_problem>(Utility::copy_problem(tr_, true));
-        va = shared_ptr<mf_problem>(Utility::copy_problem(va_, false));
-    }
-
-    // Make the training set CSR/CSC by sorting their nodes. More specifically,
-    // a matrix with values sorted by row index is CSR and vice versa. We will
-    // compute the starting location for each row (CSR) and each column (CSC)
-    // later.
-    sort(tr_csr->R, tr_csr->R+tr_csr->nnz, sort_node_by_p());
-    sort(tr_csc->R, tr_csc->R+tr_csc->nnz, sort_node_by_q());
-
-    // Save starting addresses of rows for CSR and columns for CSC.
-    mf_int u_current = -1;
-    mf_int v_current = -1;
-    for(mf_long i = 0; i < tr_->nnz; ++i)
-    {
-        mf_node* N = nullptr;
-
-        // Deal with CSR format.
-        N = tr_csr->R + i;
-        // Since tr_csr has been sorted by index u, seeing a larger index 
-        // implies a new row. Assume a node is encoded a tuple of (u, v, r),
-        // where u is row index, v is column index, and r is entry value.
-        // The nodes in tr_csr->R could be
-        //   (0, 1, 0.5), (0, 2, 3.7), (0, 4, -1.2), (2, 0, 1.2), (2, 4, 2.5) 
-        // Then, we can see the first element of the 3rd row (indexed by 2)
-        // is (2, 0, 1.2), which is the 4th element in tr_csr->R. Note that
-        // we use the row pointer of the next non-empty row as the pointers
-        // of empty rows. That is,
-        //   ptrs[0] = pointer of (0, 1, 0.5)
-        //   ptrs[1] = pointer of (0, 2, 1.5)
-        //   ptrs[2] = pointer of (0, 2, 1.5)
-        if(N->u > u_current)
-        {
-            // We (if u_current != -1) have assigned starting addresses to rows
-            // indexed by values smaller than or equal to u_current. Thus, we
-            // should handle all rows indexed starting from u_current+1 to the
-            // seen row index N->u.
-            for(mf_int u_passed = u_current + 1; u_passed <= N->u; ++u_passed)
-            {
-                // i-th non-zero value's location in tr_csr is the starting
-                // address of u_passed-th row.
-                ptrs_u[u_passed] = tr_csr->R + i;
-            }
-            u_current = N->u;
-        }
-
-        // Deal with CSC format
-        N = tr_csc->R + i;
-        if(N->v > v_current)
-        {
-            // We (if v_current != -1) have assigned starting addresses to rows
-            // indexed by values smaller than or equal to v_current. Thus, we
-            // should handle all columns indexed starting from v_current+1 to
-            // the seen row index N->v.
-            for(mf_int v_passed = v_current + 1; v_passed <= N->v; ++v_passed)
-            {
-                // i-th non-zero value's location in tr_csc is the starting
-                // address of v_passed-th column.
-                ptrs_v[v_passed] = tr_csc->R + i;
-            }
-            v_current = N->v;
-        }
-
-    }
-    // The bound of the last row. It's the address one-element behind the last
-    // matrix entry.
-    for(mf_int u_passed = u_current + 1; u_passed <= tr_->m; ++u_passed)
-        ptrs_u[u_passed] = tr_csr->R + tr_csr->nnz;
-     // The bound of the last column.
-    for(mf_int v_passed = v_current + 1; v_passed <= tr_->n; ++v_passed)
-        ptrs_v[v_passed] = tr_csc->R + tr_csc->nnz;
-
-
-    model = shared_ptr<mf_model>(Utility::init_model(tr_->m, tr_->n, param.k),
-                [] (mf_model *ptr) { mf_destroy_model(&ptr); });
-
-    ccd_one_class_core(util, tr_csr, tr_csc, va, param, ptrs_u, ptrs_v, model);
-}
-catch(exception const &e)
-{
-    cerr << e.what() << endl;
-    throw;
-}
-    return model;
-}
-
-bool check_parameter(mf_parameter param)
-{
-    if(param.fun != P_L2_MFR &&
-       param.fun != P_L1_MFR &&
-       param.fun != P_KL_MFR &&
-       param.fun != P_LR_MFC &&
-       param.fun != P_L2_MFC &&
-       param.fun != P_L1_MFC &&
-       param.fun != P_ROW_BPR_MFOC &&
-       param.fun != P_COL_BPR_MFOC &&
-       param.fun != P_L2_MFOC)
-    {
-        cerr << "unknown loss function" << endl;
-        return false;
-    }
-
-    if(param.k < 1)
-    {
-        cerr << "number of factors must be greater than zero" << endl;
-        return false;
-    }
-
-    if(param.nr_threads < 1)
-    {
-        cerr << "number of threads must be greater than zero" << endl;
-        return false;
-    }
-
-    if(param.nr_bins < 1 || param.nr_bins < param.nr_threads)
-    {
-        cerr << "number of bins must be greater than number of threads"
-             << endl;
-        return false;
-    }
-
-    if(param.nr_iters < 1)
-    {
-        cerr << "number of iterations must be greater than zero" << endl;
-        return false;
-    }
-
-    if(param.lambda_p1 < 0 ||
-       param.lambda_p2 < 0 ||
-       param.lambda_q1 < 0 ||
-       param.lambda_q2 < 0)
-    {
-        cerr << "regularization coefficient must be non-negative" << endl;
-        return false;
-    }
-
-    if(param.eta <= 0)
-    {
-        cerr << "learning rate must be greater than zero" << endl;
-        return false;
-    }
-
-    if(param.fun == P_KL_MFR && !param.do_nmf)
-    {
-        cerr << "--nmf must be set when using generalized KL-divergence"
-             << endl;
-        return false;
-    }
-
-    if(param.nr_bins <= 2*param.nr_threads)
-    {
-        cerr << "Warning: insufficient blocks may slow down the training"
-             << "process (4*nr_threads^2+1 blocks is suggested)" << endl;
-    }
-
-    if(param.nr_bins <= 2*param.nr_threads)
-    {
-        cerr << "Warning: insufficient blocks may slow down the training"
-             << "process (4*nr_threads^2+1 blocks is suggested)" << endl;
-    }
-
-    if(param.alpha < 0)
-    {
-        cerr << "alpha must be a non-negative number" << endl;
-    }
-
-    return true;
-}
-
-//--------------------------------------
-//-----Classes for cross validation-----
-//--------------------------------------
-
-class CrossValidatorBase
-{
-public:
-    CrossValidatorBase(mf_parameter param_, mf_int nr_folds_);
-    mf_double do_cross_validation();
-    virtual mf_double do_cv1(vector<mf_int> &hidden_blocks) = 0;
-protected:
-    mf_parameter param;
-    mf_int nr_bins;
-    mf_int nr_folds;
-    mf_int nr_blocks_per_fold;
-    bool quiet;
-    Utility util;
-    mf_double cv_error;
-};
-
-CrossValidatorBase::CrossValidatorBase(mf_parameter param_, mf_int nr_folds_)
-    : param(param_), nr_bins(param_.nr_bins), nr_folds(nr_folds_),
-      nr_blocks_per_fold(nr_bins*nr_bins/nr_folds), quiet(param_.quiet),
-      util(param.fun, param.nr_threads), cv_error(0)
-{
-    param.quiet = true;
-}
-
-mf_double CrossValidatorBase::do_cross_validation()
-{
-    vector<mf_int> cv_blocks;
-    srand(0);
-    for(mf_int block = 0; block < nr_bins*nr_bins; ++block)
-        cv_blocks.push_back(block);
-    random_shuffle(cv_blocks.begin(), cv_blocks.end());
-
-    if(!quiet)
-    {
-        cout.width(4);
-        cout << "fold";
-        cout.width(10);
-        cout << util.get_error_legend();
-        cout << endl;
-    }
-
-    cv_error = 0;
-
-    for(mf_int fold = 0; fold < nr_folds; ++fold)
-    {
-        mf_int begin = fold*nr_blocks_per_fold;
-        mf_int end = min((fold+1)*nr_blocks_per_fold, nr_bins*nr_bins);
-        vector<mf_int> hidden_blocks(cv_blocks.begin()+begin,
-                                    cv_blocks.begin()+end);
-
-        mf_double err = do_cv1(hidden_blocks);
-        cv_error += err;
-
-        if(!quiet)
-        {
-            cout.width(4);
-            cout << fold;
-            cout.width(10);
-            cout << fixed << setprecision(4) << err;
-            cout << endl;
-        }
-    }
-
-    if(!quiet)
-    {
-        cout.width(14);
-        cout.fill('=');
-        cout << "" << endl;
-        cout.fill(' ');
-        cout.width(4);
-        cout << "avg";
-        cout.width(10);
-        cout << fixed << setprecision(4) << cv_error/nr_folds;
-        cout << endl;
-    }
-
-    return cv_error/nr_folds;
-}
-
-class CrossValidator : public CrossValidatorBase
-{
-public:
-    CrossValidator(
-        mf_parameter param_, mf_int nr_folds_, mf_problem const *prob_)
-        : CrossValidatorBase(param_, nr_folds_), prob(prob_) {};
-    mf_double do_cv1(vector<mf_int> &hidden_blocks);
-private:
-    mf_problem const *prob;
-};
-
-mf_double CrossValidator::do_cv1(vector<mf_int> &hidden_blocks)
-{
-    mf_double err = 0;
-    fpsg(prob, nullptr, param, hidden_blocks, &err);
-    return err;
-}
-
-class CrossValidatorOnDisk : public CrossValidatorBase
-{
-public:
-    CrossValidatorOnDisk(
-        mf_parameter param_, mf_int nr_folds_, string data_path_)
-        : CrossValidatorBase(param_, nr_folds_), data_path(data_path_) {};
-    mf_double do_cv1(vector<mf_int> &hidden_blocks);
-private:
-    string data_path;
-};
-
-mf_double CrossValidatorOnDisk::do_cv1(vector<mf_int> &hidden_blocks)
-{
-    mf_double err = 0;
-    fpsg_on_disk(data_path, string(), param, hidden_blocks, &err);
-    return err;
-}
-
-} // unnamed namespace
-
-mf_model* mf_train_with_validation(
-    mf_problem const *tr,
-    mf_problem const *va,
-    mf_parameter param)
-{
-    if(!check_parameter(param))
-        return nullptr;
-
-    shared_ptr<mf_model> model(nullptr);
-    
-    if(param.fun != P_L2_MFOC)
-        // Use stochastic gradient method
-        model = fpsg(tr, va, param);
-    else
-        // Use coordinate descent method
-        model = ccd_one_class(tr, va, param); 
-
-    mf_model *model_ret = new mf_model;
-
-    model_ret->fun = model->fun;
-    model_ret->m = model->m;
-    model_ret->n = model->n;
-    model_ret->k = model->k;
-    model_ret->b = model->b;
-
-    model_ret->P = model->P;
-    model->P = nullptr;
-
-    model_ret->Q = model->Q;
-    model->Q = nullptr;
-
-    return model_ret;
-}
-
-mf_model* mf_train_with_validation_on_disk(
-    char const *tr_path,
-    char const *va_path,
-    mf_parameter param)
-{
-    // Two conditions lead to empty model. First, any parameter is not in its
-    // supported range. Second, one-class matrix facotorization with L2-loss
-    // (-f 12) doesn't support disk-level training.
-    if(!check_parameter(param) || param.fun == P_L2_MFOC)
-        return nullptr;
-
-    shared_ptr<mf_model> model = fpsg_on_disk(
-        string(tr_path), string(va_path), param);
-
-    mf_model *model_ret = new mf_model;
-
-    model_ret->fun = model->fun;
-    model_ret->m = model->m;
-    model_ret->n = model->n;
-    model_ret->k = model->k;
-    model_ret->b = model->b;
-
-    model_ret->P = model->P;
-    model->P = nullptr;
-
-    model_ret->Q = model->Q;
-    model->Q = nullptr;
-
-    return model_ret;
-}
-
-mf_model* mf_train(mf_problem const *prob, mf_parameter param)
-{
-    return mf_train_with_validation(prob, nullptr, param);
-}
-
-mf_model* mf_train_on_disk(char const *tr_path, mf_parameter param)
-{
-    return mf_train_with_validation_on_disk(tr_path, "", param);
-}
-
-mf_double mf_cross_validation(
-    mf_problem const *prob,
-    mf_int nr_folds,
-    mf_parameter param)
-{
-    // Two conditions lead to empty model. First, any parameter is not in its
-    // supported range. Second, one-class matrix facotorization with L2-loss
-    // (-f 12) doesn't support disk-level training.
-    if(!check_parameter(param) || param.fun == P_L2_MFOC)
-        return 0;
-
-    CrossValidator validator(param, nr_folds, prob);
-
-    return validator.do_cross_validation();
-}
-
-mf_double mf_cross_validation_on_disk(
-    char const *prob,
-    mf_int nr_folds,
-    mf_parameter param)
-{
-    // Two conditions lead to empty model. First, any parameter is not in its
-    // supported range. Second, one-class matrix facotorization with L2-loss
-    // (-f 12) doesn't support disk-level training.
-    if(!check_parameter(param) || param.fun == P_L2_MFOC)
-        return 0;
-
-    CrossValidatorOnDisk validator(param, nr_folds, string(prob));
-
-    return validator.do_cross_validation();
-}
-
-mf_problem read_problem(string path)
-{
-    mf_problem prob;
-    prob.m = 0;
-    prob.n = 0;
-    prob.nnz = 0;
-    prob.R = nullptr;
-
-    if(path.empty())
-        return prob;
-
-    ifstream f(path);
-    if(!f.is_open())
-        return prob;
-
-    string line;
-    while(getline(f, line))
-        prob.nnz += 1;
-
-    mf_node *R = new mf_node[static_cast<size_t>(prob.nnz)];
-
-    f.close();
-    f.open(path);
-
-    mf_long idx = 0;
-    for(mf_node N; f >> N.u >> N.v >> N.r;)
-    {
-        if(N.u+1 > prob.m)
-            prob.m = N.u+1;
-        if(N.v+1 > prob.n)
-            prob.n = N.v+1;
-        R[idx] = N;
-        ++idx;
-    }
-    prob.R = R;
-
-    f.close();
-
-    return prob;
-}
-
-mf_int mf_save_model(mf_model const *model, char const *path)
-{
-    ofstream f(path);
-    if(!f.is_open())
-        return 1;
-
-    f << "f " << model->fun << endl;
-    f << "m " << model->m << endl;
-    f << "n " << model->n << endl;
-    f << "k " << model->k << endl;
-    f << "b " << model->b << endl;
-
-    auto write = [&] (mf_float *ptr, mf_int size, char prefix)
-    {
-        for(mf_int i = 0; i < size; ++i)
-        {
-            mf_float *ptr1 = ptr + (mf_long)i*model->k;
-            f << prefix << i << " ";
-            if(isnan(ptr1[0]))
-            {
-                f << "F ";
-                for(mf_int d = 0; d < model->k; ++d)
-                    f << 0 << " ";
-            }
-            else
-            {
-                f << "T ";
-                for(mf_int d = 0; d < model->k; ++d)
-                    f << ptr1[d] << " ";
-            }
-            f << endl;
-        }
-
-    };
-
-    write(model->P, model->m, 'p');
-    write(model->Q, model->n, 'q');
-
-    f.close();
-
-    return 0;
-}
-
-mf_model* mf_load_model(char const *path)
-{
-    ifstream f(path);
-    if(!f.is_open())
-        return nullptr;
-
-    string dummy;
-
-    mf_model *model = new mf_model;
-    model->P = nullptr;
-    model->Q = nullptr;
-
-    f >> dummy >> model->fun >> dummy >> model->m >> dummy >> model->n >>
-         dummy >> model->k >> dummy >> model->b;
-
-    try
-    {
-        model->P = Utility::malloc_aligned_float((mf_long)model->m*model->k);
-        model->Q = Utility::malloc_aligned_float((mf_long)model->n*model->k);
-    }
-    catch(bad_alloc const &e)
-    {
-        cerr << e.what() << endl;
-        mf_destroy_model(&model);
-        return nullptr;
-    }
-
-    auto read = [&] (mf_float *ptr, mf_int size)
-    {
-        for(mf_int i = 0; i < size; ++i)
-        {
-            mf_float *ptr1 = ptr + (mf_long)i*model->k;
-            f >> dummy >> dummy;
-            if(dummy.compare("F") == 0) // nan vector starts with "F"
-                for(mf_int d = 0; d < model->k; ++d)
-                {
-                    f >> dummy;
-                    ptr1[d] = numeric_limits<mf_float>::quiet_NaN();
-                }
-            else
-                for(mf_int d = 0; d < model->k; ++d)
-                    f >> ptr1[d];
-        }
-    };
-
-    read(model->P, model->m);
-    read(model->Q, model->n);
-
-    f.close();
-
-    return model;
-}
-
-void mf_destroy_model(mf_model **model)
-{
-    if(model == nullptr || *model == nullptr)
-        return;
-    Utility::free_aligned_float((*model)->P);
-    Utility::free_aligned_float((*model)->Q);
-    delete *model;
-    *model = nullptr;
-}
-
-mf_float mf_predict(mf_model const *model, mf_int u, mf_int v)
-{
-    if(u < 0 || u >= model->m || v < 0 || v >= model->n)
-        return model->b;
-
-    mf_float *p = model->P+(mf_long)u*model->k;
-    mf_float *q = model->Q+(mf_long)v*model->k;
-
-    mf_float z = std::inner_product(p, p+model->k, q, (mf_float)0.0f);
-
-    if(isnan(z))
-        z = model->b;
-
-    if(model->fun == P_L2_MFC ||
-       model->fun == P_L1_MFC ||
-       model->fun == P_LR_MFC)
-        z = z > 0.0f? 1.0f: -1.0f;
-
-    return z;
-}
-
-mf_double calc_rmse(mf_problem *prob, mf_model *model)
-{
-    if(prob->nnz == 0)
-        return 0;
-    mf_double loss = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+:loss)
-#endif
-    for(mf_long i = 0; i < prob->nnz; ++i)
-    {
-        mf_node &N = prob->R[i];
-        mf_float e = N.r - mf_predict(model, N.u, N.v);
-        loss += e*e;
-    }
-    return sqrt(loss/prob->nnz);
-}
-
-mf_double calc_mae(mf_problem *prob, mf_model *model)
-{
-    if(prob->nnz == 0)
-        return 0;
-    mf_double loss = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+:loss)
-#endif
-    for(mf_long i = 0; i < prob->nnz; ++i)
-    {
-        mf_node &N = prob->R[i];
-        loss += abs(N.r - mf_predict(model, N.u, N.v));
-    }
-    return loss/prob->nnz;
-}
-
-mf_double calc_gkl(mf_problem *prob, mf_model *model)
-{
-    if(prob->nnz == 0)
-        return 0;
-    mf_double loss = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+:loss)
-#endif
-    for(mf_long i = 0; i < prob->nnz; ++i)
-    {
-        mf_node &N = prob->R[i];
-        mf_float z = mf_predict(model, N.u, N.v);
-        loss += N.r*log(N.r/z)-N.r+z;
-    }
-    return loss/prob->nnz;
-}
-
-mf_double calc_logloss(mf_problem *prob, mf_model *model)
-{
-    if(prob->nnz == 0)
-        return 0;
-    mf_double logloss = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+:logloss)
-#endif
-    for(mf_long i = 0; i < prob->nnz; ++i)
-    {
-        mf_node &N = prob->R[i];
-        mf_float z = mf_predict(model, N.u, N.v);
-        if(N.r > 0)
-            logloss += log(1.0+exp(-z));
-        else
-            logloss += log(1.0+exp(z));
-    }
-    return logloss/prob->nnz;
-}
-
-mf_double calc_accuracy(mf_problem *prob, mf_model *model)
-{
-    if(prob->nnz == 0)
-        return 0;
-    mf_double acc = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+:acc)
-#endif
-    for(mf_long i = 0; i < prob->nnz; ++i)
-    {
-        mf_node &N = prob->R[i];
-        mf_float z = mf_predict(model, N.u, N.v);
-        if(N.r > 0)
-            acc += z > 0? 1: 0;
-        else
-            acc += z < 0? 1: 0;
-    }
-    return acc/prob->nnz;
-}
-
-pair<mf_double, mf_double> calc_mpr_auc(mf_problem *prob,
-                                        mf_model *model, bool transpose)
-{
-    mf_int mf_node::*row_ptr;
-    mf_int mf_node::*col_ptr;
-    mf_int m = 0, n = 0;
-    if(!transpose)
-    {
-        row_ptr = &mf_node::u;
-        col_ptr = &mf_node::v;
-        m = max(prob->m, model->m);
-        n = max(prob->n, model->n);
-    }
-    else
-    {
-        row_ptr = &mf_node::v;
-        col_ptr = &mf_node::u;
-        m = max(prob->n, model->n);
-        n = max(prob->m, model->m);
-    }
-
-    auto sort_by_id = [&] (mf_node const &lhs, mf_node const &rhs)
-    {
-        return tie(lhs.*row_ptr, lhs.*col_ptr) <
-               tie(rhs.*row_ptr, rhs.*col_ptr);
-    };
-
-    sort(prob->R, prob->R+prob->nnz, sort_by_id);
-
-    auto sort_by_pred = [&] (pair<mf_node, mf_float> const &lhs,
-        pair<mf_node, mf_float> const &rhs) { return lhs.second < rhs.second; };
-
-    vector<mf_int> pos_cnts(m+1, 0);
-    for(mf_int i = 0; i < prob->nnz; ++i)
-        pos_cnts[prob->R[i].*row_ptr+1] += 1;
-    for(mf_int i = 1; i < m+1; ++i)
-        pos_cnts[i] += pos_cnts[i-1];
-
-    mf_int total_m = 0;
-    mf_long total_pos = 0;
-    mf_double all_u_mpr = 0;
-    mf_double all_u_auc = 0;
-#if defined USEOMP
-#pragma omp parallel for schedule(static) reduction(+: total_m, total_pos, all_u_mpr, all_u_auc)
-#endif
-    for(mf_int i = 0; i < m; ++i)
-    {
-        if(pos_cnts[i+1]-pos_cnts[i] < 1)
-            continue;
-
-        vector<pair<mf_node, mf_float>> row(n);
-
-        for(mf_int j = 0; j < n; ++j)
-        {
-            mf_node N;
-            N.*row_ptr = i;
-            N.*col_ptr = j;
-            N.r = 0;
-            row[j] = make_pair(N, mf_predict(model, N.u, N.v));
-        }
-
-        mf_int pos = 0;
-        vector<mf_int> index(pos_cnts[i+1]-pos_cnts[i], 0);
-        for(mf_int j = pos_cnts[i]; j < pos_cnts[i+1]; ++j)
-        {
-            if(prob->R[j].r <= 0)
-                continue;
-
-            mf_int col = prob->R[j].*col_ptr;
-            row[col].first.r = prob->R[j].r;
-            index[pos] = col;
-            pos += 1;
-        }
-
-        if(n-pos < 1 || pos < 1)
-            continue;
-
-        ++total_m;
-        total_pos += pos;
-
-        mf_int count = 0;
-        for(mf_int k = 0; k < pos; ++k)
-        {
-            swap(row[count], row[index[k]]);
-            ++count;
-        }
-        sort(row.begin(), row.begin()+pos, sort_by_pred);
-
-        mf_double u_mpr = 0;
-        mf_double u_auc = 0;
-        for(auto neg_it = row.begin()+pos; neg_it != row.end(); ++neg_it)
-        {
-            if(row[pos-1].second <= neg_it->second)
-            {
-                u_mpr += pos;
-                continue;
-            }
-
-            mf_int left = 0;
-            mf_int right = pos-1;
-            while(left < right)
-            {
-                mf_int mid = (left+right)/2;
-                if(row[mid].second > neg_it->second)
-                    right = mid;
-                else
-                    left = mid+1;
-            }
-            u_mpr += left;
-            u_auc += pos-left;
-        }
-
-        all_u_mpr += u_mpr/(n-pos);
-        all_u_auc += u_auc/(n-pos)/pos;
-    }
-
-    all_u_mpr /= total_pos;
-    all_u_auc /= total_m;
-
-    return make_pair(all_u_mpr, all_u_auc);
-}
-
-mf_double calc_mpr(mf_problem *prob, mf_model *model, bool transpose)
-{
-    return calc_mpr_auc(prob, model, transpose).first;
-}
-
-mf_double calc_auc(mf_problem *prob, mf_model *model, bool transpose)
-{
-    return calc_mpr_auc(prob, model, transpose).second;
-}
-
-mf_parameter mf_get_default_param()
-{
-    mf_parameter param;
-
-    param.fun = P_L2_MFR;
-    param.k = 8;
-    param.nr_threads = 12;
-    param.nr_bins = 20;
-    param.nr_iters = 20;
-    param.lambda_p1 = 0.0f;
-    param.lambda_q1 = 0.0f;
-    param.lambda_p2 = 0.1f;
-    param.lambda_q2 = 0.1f;
-    param.eta = 0.1f;
-    param.alpha = 1.0f;
-    param.c = 0.0001f;
-    param.do_nmf = false;
-    param.quiet = false;
-    param.copy_data = true;
-
-    return param;
-}
-
-}