def test_simple_rectangular_real(self):
     a = [[1, 2], [3.5, 4], [5, 6]]
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (3, 2, 6, "array", "real", "general"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_rectangular(self):
     a = [[1, 2, 3], [4, 5, 6]]
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (2, 3, 6, "array", "integer", "general"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_skew_symmetric(self):
     a = [[1,2],[-2,4]]
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,2,4,'array','integer','skew-symmetric'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def matrixFactorization_graphlab(self,rows,cols,r,c,algo):
     if platform.system() == 'Windows':
         base_dir = 'D:'
     elif platform.system() == 'Linux':
         base_dir = '/workspace'
                         
     # Pull out the sparse sub-matrix for current co-cluster
     #print r,c
     Y_sparse = self.coo_submatrix_pull(rows,cols)
     # Convert Data into Matrix Market format and write the Training data to file
     Y_mm_file_name = base_dir + '/sdap/data/temp/mf'
     # Remove the current files in .../data/temp/
     #cmd = "rm -f" + base_dir + "/sdap/data/temp/*"
     #os.system(cmd)
     if os.path.isdir(base_dir + "/sdap/data/temp/"):
         shutil.rmtree(base_dir + "/sdap/data/temp/")
     os.mkdir(base_dir + "/sdap/data/temp/")
     Y_mm_file = open(Y_mm_file_name,'w')
     mm.mmwrite(Y_mm_file,Y_sparse,comment="")
     
     # Call Matrix Factorization code
     cmd = "~/graphlabapi/release/demoapps/pmf/pmf "+ Y_mm_file_name +" --matrixmarket=true --D="+str(self.D)+" --lambda="+str(self.lambda_reg)+" --minval=0.5 --maxval=5.0 --ncpus=16 --max_iter=50 --threshold=1e-6"
     subprocess.call(cmd,shell=True)#,stdout=subprocess.PIPE,stderr=subprocess.STDOUT) #TO DO replace 
     #os.system(cmd)
 
     # Read all the files for the output Latent Factors and return Us and Vs
     U,V = self.readLatentFactors(base_dir)
     #print U.shape, len(rows)
     #print V.shape, len(cols)
     #import sys
     #sys.exit()
     
     return U,V        

 def test_simple_skew_symmetric_float(self):
     a = array([[1, 2], [-2.0, 4]], "f")
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (2, 2, 4, "array", "real", "skew-symmetric"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_hermitian(self):
     a = [[1, 2 + 3j], [2 - 3j, 4]]
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (2, 2, 4, "array", "complex", "hermitian"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_skew_symmetric(self):
     a = [[1, 2], [-2, 4]]
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (2, 2, 4, "array", "integer", "skew-symmetric"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_complex(self):
     a = [[1,2],[3,4j]]
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,2,4,'array','complex','general'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_simple_hermitian(self):
     a = [[1,2+3j],[2-3j,4]]
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,2,4,'array','complex','hermitian'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_simple_skew_symmetric_float(self):
     a = array([[1,2],[-2.0,4]],'f')
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,2,4,'array','real','skew-symmetric'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_simple_complex(self):
     a = [[1, 2], [3, 4j]]
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (2, 2, 4, "array", "complex", "general"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_rectangular_real(self):
     a = [[1,2],[3.5,4],[5,6]]
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(3,2,6,'array','real','general'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_simple_rectangular(self):
     a = [[1,2,3],[4,5,6]]
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,3,6,'array','integer','general'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_simple_real(self):
     a = [[1,2],[3,4.0]]
     fn = self.fn
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(2,2,4,'array','real','general'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_random_rect_real(self):
     sz = (20,15)
     a = rand(*sz)
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(20,15,300,'array','real','general'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_random_rect_real(self):
     sz = (20, 15)
     a = rand(*sz)
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (20, 15, 300, "array", "real", "general"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

 def test_simple_pattern(self):
     a = scipy.sparse.csr_matrix([[0, 1.5], [3.0, 2.5]])
     p = np.zeros_like(a.todense())
     p[a.todense() > 0] = 1
     info = (2, 2, 3, 'coordinate', 'pattern', 'general')
     mmwrite(self.fn, a, field='pattern')
     assert_equal(mminfo(self.fn), info)
     b = mmread(self.fn)
     assert_array_almost_equal(p, b.todense())

 def test_random_symmetric_real(self):
     sz = (20,20)
     a = rand(*sz)
     a = a + transpose(a)
     fn = mktemp()
     mmwrite(fn,a)
     assert_equal(mminfo(fn),(20,20,400,'array','real','symmetric'))
     b = mmread(fn)
     assert_array_almost_equal(a,b)

 def test_random_symmetric_real(self):
     sz = (20, 20)
     a = rand(*sz)
     a = a + transpose(a)
     fn = self.fn
     mmwrite(fn, a)
     assert_equal(mminfo(fn), (20, 20, 400, "array", "real", "symmetric"))
     b = mmread(fn)
     assert_array_almost_equal(a, b)

    def test_empty_write_read(self):
        # https://github.com/scipy/scipy/issues/1410 (Trac #883)

        b = scipy.sparse.coo_matrix((10, 10))
        mmwrite(self.fn, b)

        assert_equal(mminfo(self.fn),
                     (10, 10, 0, 'coordinate', 'real', 'symmetric'))
        a = b.todense()
        b = mmread(self.fn).todense()
        assert_array_almost_equal(a, b)