{"id":3851,"date":"2025-08-12T09:42:54","date_gmt":"2025-08-12T13:42:54","guid":{"rendered":"https:\/\/blogs.mathworks.com\/matlab\/?p=3851"},"modified":"2025-08-13T06:40:37","modified_gmt":"2025-08-13T10:40:37","slug":"new-in-matlab-single-precision-sparse-matrices","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/matlab\/2025\/08\/12\/new-in-matlab-single-precision-sparse-matrices\/","title":{"rendered":"New in MATLAB: Single precision sparse matrices"},"content":{"rendered":"
Sparse matrices<\/span><\/a> have been in MATLAB for a long time but, up until now, the only types of sparse matrices you could create were <\/span>double<\/span> or <\/span>logical <\/span>sparse matrices.<\/span><\/div>
This is no longer the case and one of the thousands of new features in <\/span>MATLAB R2025a<\/span><\/a> is the fact that you can now create and use <\/span>single<\/span> precision sparse matrices. For example, here is how you create a random single precision sparse matrix of size 50 <\/span>x<\/span> 100 with density 0.001.<\/span><\/div>
mySparseSingleMat = sprand(50,100,0.001,<\/span>\"single\"<\/span>)<\/span><\/span><\/div>
mySparseSingleMat = 50\u00d7100 sparse single matrix (5 nonzeros)<\/span><\/span><\/div>
(39,4) 0.7142\r\n (46,67) 0.9240\r\n (4,69) 0.8103\r\n (37,74) 0.5364\r\n (33,89) 0.0137\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
The <\/span>\"single\"<\/span> argument is new and is also available for several other sparse matrix creation functions such as <\/span>sparse<\/span><\/a>, <\/span>speye<\/span><\/a>, <\/span>spalloc<\/span><\/a>, <\/span>sprandn<\/span><\/a> <\/span>and <\/span>sprandsym<\/span><\/a>.<\/span> As with previous versions, if you don't specify any type then the default is <\/span>double<\/span> but you can now also be explicit if you prefer.<\/span><\/div>
mySpeyeSingleMat = speye(5,<\/span>\"double\"<\/span>)<\/span><\/span><\/div>
mySpeyeSingleMat = 5\u00d75 sparse double matrix (5 nonzeros)<\/span><\/span><\/div>
(1,1) 1\r\n (2,2) 1\r\n (3,3) 1\r\n (4,4) 1\r\n (5,5) 1\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Support for single precision sparse matrices has been on many people's wish-lists for a long time and its great news that we now have them. In the remainder of this post I'm going to dig into some of the details about why single precision sparse matrices are useful, why it was a lot of work to add them to MATLAB and a couple of tips about best practice when using them. <\/span><\/div>

Single precision sparse matrices save memory<\/span><\/h2>
A <\/span>double<\/span> precision number requires 64-bits (8 bytes) to store it while a <\/span>single<\/span> precision number uses 32-bits (4 bytes). So, the first benefit of using a <\/span>single<\/span> sparse matrix is that it requires less memory compared to the <\/span>double<\/span> version <\/span>but at the cost of reduced precision<\/span>. Given this information, your first guess might be that a <\/span>single<\/span> sparse matrix requires half the space of a <\/span>double<\/span> sparse matrix, which is the case for dense matrices. If so, your first guess is wrong<\/span><\/div>
mySparseDoubleMat = sprand(50,100,0.001,<\/span>\"double\"<\/span>)<\/span><\/span><\/div>
mySparseDoubleMat = 50\u00d7100 sparse double matrix (5 nonzeros)<\/span><\/span><\/div>
(27,5) 0.8934\r\n (45,5) 0.4957\r\n (45,39) 0.3892\r\n (31,68) 0.2711\r\n (11,81) 0.1672\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
We use the <\/span>whos<\/span><\/a> function to determine how much memory this matrix is using<\/span><\/div>
whos <\/span>mySparseDoubleMat<\/span><\/span><\/div>
Name Size Bytes Class Attributes\r\n\r\n mySparseDoubleMat 50x100 888 double sparse <\/div><\/div><\/div><\/div><\/div>
Let's now create a <\/span>single<\/span> sparse matrix with the same size and with the same number of non-zero elements<\/span><\/div>
mySparseSingleMat = sprand(50,100,0.001,<\/span>\"single\"<\/span>)<\/span><\/span><\/div>
mySparseSingleMat = 50\u00d7100 sparse single matrix (5 nonzeros)<\/span><\/span><\/div>
(20,6) 0.2901\r\n (44,19) 0.7310\r\n (19,76) 0.2183\r\n (34,85) 0.7405\r\n (22,92) 0.9392\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
Again, we show how much memory this is using<\/span><\/div>
whos <\/span>mySparseSingleMat<\/span><\/span><\/div>
Name Size Bytes Class Attributes\r\n\r\n mySparseSingleMat 50x100 868 single sparse <\/div><\/div><\/div><\/div><\/div>
The <\/span>double<\/span> sparse matrix is using 888 bytes while <\/span>single<\/span> <\/span>sparse is using 868 bytes -- a saving of only 20 bytes! The reason for this is that along with the actual values of the non-zeros, sparse matrices have to store their locations. The memory required for location storage of the non-zeros is the same no matter what precision the actual values are.<\/span><\/div>
In the two examples given above, the memory required for the storage of the locations of the non-zeros is identical. The difference between them is simply that the 5 non-zeros are stored as <\/span>double<\/span> in the first case (and hence taking up 40 bytes) and <\/span>single <\/span>in the second case (and hence using 20 bytes) which gives us the 20 byte difference between the two.<\/span><\/div>
Both are significantly better than the <\/span>50 x 100 x 8 = 40,000<\/span> bytes for the dense <\/span>double<\/span> matrix or <\/span>50 x 100 x 4 = 20,000 <\/span>bytes for the dense <\/span>single<\/span> matrix. For dense matrices, a zero takes up just as much memory space as any other number. Sparse matrices can save a lot of memory and <\/span>single<\/span> sparse matrices can save even more, particularly when dealing with very large matrices with a large number of non-zero elements. For example, consider this sparse double matrix<\/span><\/div>
largeDoubleSparse = sprand(10000,10000,0.1,<\/span>\"double\"<\/span>);<\/span><\/span><\/div><\/div>
fprintf(<\/span>\"This double matrix has %d non-zeros\\n\"<\/span>,nnz(largeDoubleSparse))<\/span><\/span><\/div>
This double matrix has 9515142 non-zeros<\/div><\/div><\/div><\/div><\/div>
Let's see how much memory this matrix is using<\/span><\/div>
whos <\/span>largeDoubleSparse<\/span><\/span><\/div>
Name Size Bytes Class Attributes\r\n\r\n largeDoubleSparse 10000x10000 152322280 double sparse <\/div><\/div><\/div><\/div><\/div>
A single precision version of the same matrix is about 25% smaller in memory, saving about 36 Megabytes in this instance. <\/span><\/div>
largeSingleSparse = single(largeDoubleSparse);<\/span><\/span><\/div><\/div>
whos <\/span>largeSingleSparse<\/span><\/span><\/div>
Name Size Bytes Class Attributes\r\n\r\n largeSingleSparse 10000x10000 114261712 single sparse <\/div><\/div><\/div><\/div><\/div>
<\/span><\/div>

Operations with single sparse matrices can be faster<\/span><\/h2>
Roughly speaking, since we have fewer bytes to compute when operating on <\/span>single<\/span> precision numbers, we can expect to compute things more quickly compared to <\/span>double<\/span> precision. Iterative computations are often faster too since we have fewer decimal places of precision to worry about.<\/span><\/div>
As an example, let's create a large <\/span>double sparse <\/span>random matrix and time how long it takes to find the largest 6 singular values using <\/span>svds<\/span><\/a><\/div>
rng(5); <\/span>% Seed the random number generator for <\/span>reproducibility<\/span><\/span><\/div><\/div>
randDoubleSparse = sprand(40000,10000,0.0005,<\/span>\"double\"<\/span>);<\/span><\/span><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
svds(randDoubleSparse,6,<\/span>\"largest\"<\/span>)<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
ans = <\/span>6\u00d71<\/span><\/div><\/div>
5.9095\r\n 4.2673\r\n 4.2507\r\n 4.2486\r\n 4.2456\r\n 4.2381\r\n<\/div>
<\/mw-icon><\/div>
<\/mw-icon><\/div><\/div><\/div><\/div><\/div><\/div>
doubleSvdsTime = toc<\/span><\/span><\/div>
doubleSvdsTime = <\/span>1.7272<\/div><\/div><\/div><\/div><\/div><\/div>
Now I'll cast the large random matrix to <\/span>single<\/span> precision so that the only difference between these two matrices is the precision. <\/span><\/div>
randSingleSparse = single(randDoubleSparse);<\/span><\/span><\/div><\/div><\/div>
I perform the <\/span>svds<\/span> calculation on the result<\/span><\/div>
tic<\/span><\/span><\/div><\/div>
svds(randSingleSparse,6,<\/span>\"largest\"<\/span>)<\/span><\/span><\/div>
<\/div>
<\/div>
<\/div>
<\/div>
ans = <\/span>6\u00d71 single column vector<\/span><\/div><\/div>
5.9095\r\n 4.2673\r\n 4.2507\r\n 4.2486\r\n 4.2456\r\n 4.2381\r\n<\/div>
<\/mw-icon><\/div>
<\/mw-icon><\/div><\/div><\/div><\/div><\/div><\/div>
singleSvdsTime = toc<\/span><\/span><\/div>
singleSvdsTime = <\/span>1.2296<\/div><\/div><\/div><\/div><\/div><\/div>
Which is a very nice speed-up! <\/span><\/div>
fprintf(<\/span>\"The speed-up gained from using single precision was %f times\\n\"<\/span>,doubleSvdsTime\/singleSvdsTime)<\/span><\/span><\/div>
The speed-up gained from using single precision was 1.404657 times<\/div><\/div><\/div><\/div><\/div>
The primary reason for this is that the tolerance is reduced for <\/span>single<\/span> inputs. <\/span>svds<\/span> sets the default tolerance to 1e-5 instead of 1e-10 because 1e-10 is not reachable in single-precision. T<\/span>his is something you should always bear in mind when using <\/span>single<\/span> precision for anything; yes, it can be faster but you always pay the cost of reduced precision.<\/span><\/div>
The reduction in precision isn't the only reason why this operation is faster though. Let's request the exact same tolerance in both <\/span>double<\/span> and <\/span>single<\/span> cases<\/span><\/div>
tic; svds(randDoubleSparse,6,<\/span>\"largest\"<\/span>,Tolerance=1e-4); toc<\/span><\/span><\/div>
Elapsed time is 1.215458 seconds.<\/div><\/div><\/div><\/div><\/div>
single<\/span> is still faster.<\/span><\/div>
tic; svds(randSingleSparse,6,<\/span>\"largest\"<\/span>,Tolerance=1e-4); toc<\/span><\/span><\/div>
Elapsed time is 0.866802 seconds.<\/div><\/div><\/div><\/div><\/div>
Several other iterative solvers such as <\/span>eigs<\/span>, <\/span>pcg<\/span>, <\/span>minres<\/span> and <\/span>gmres<\/span> might also be faster when using <\/span>single<\/span> sparse matrices for similar reasons but I haven't investigated.<\/span><\/div>

Matrix-vector products are faster too<\/span><\/h2>
An example of a non-iterative algorithm where moving to <\/span>single<\/span> sparse gives a performance boost is multiplying a sparse matrix by a dense vector. Even for large matrices, this is a fast operation so I'll do it 100 times and time that.<\/span><\/div>
First in double precision<\/span><\/div>
randDoubleSparse = sprand(80000,80000,0.0006,<\/span>\"double\"<\/span>);<\/span><\/span><\/div><\/div>
randDoubleVector = rand(80000,1,<\/span>\"double\"<\/span>);<\/span><\/span><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
for <\/span>repeats = 1:100<\/span><\/span><\/div><\/div>
singleSquared = randDoubleSparse * randDoubleVector;<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
toc<\/span><\/span><\/div>
Elapsed time is 1.995894 seconds.<\/div><\/div><\/div><\/div><\/div>
and now in single precision<\/span><\/div>
randSingleSparse = sprand(80000,80000,0.0006,<\/span>\"single\"<\/span>);<\/span><\/span><\/div><\/div>
randSingleVector = rand(80000,1,<\/span>\"single\"<\/span>);<\/span><\/span><\/div><\/div>
tic<\/span><\/span><\/div><\/div>
for <\/span>repeats = 1:100<\/span><\/span><\/div><\/div>
singleSquared = randSingleSparse * randSingleVector;<\/span><\/span><\/div><\/div>
end<\/span><\/span><\/div><\/div>
toc<\/span><\/span><\/div>
Elapsed time is 0.703923 seconds.<\/div><\/div><\/div><\/div><\/div>
Again, this is another nice speed-up.<\/span><\/div>
Speaking of speed....<\/span><\/div>

Single Sparse works on GPUs and distributed arrays as well<\/span><\/h2>
As part of a cross-team collaboration, the Parallel Computing Toolbox team ensured that you can use single precision sparse matrices on GPUs too. You can transfer <\/span>single<\/span> sparse matrices created earlier from main memory to the GPU using <\/span>gpuArray<\/span><\/div>
gpuSparse = gpuArray(mySparseSingleMat)<\/span><\/span><\/div>
gpuSparse =\r\n\r\n 50\u00d7100 sparse gpuArray single matrix (5 nonzeros)\r\n\r\n (20,6) 0.2901\r\n (44,19) 0.7310\r\n (19,76) 0.2183\r\n (34,85) 0.7405\r\n (22,92) 0.9392<\/div><\/div><\/div><\/div><\/div>
or you can create them directly in GPU memory<\/span><\/div>
R = gpuArray.sprand(50,100,0.001,<\/span>\"single\"<\/span>)<\/span><\/span><\/div>
R =\r\n\r\n 50\u00d7100 sparse gpuArray single matrix (5 nonzeros)\r\n\r\n (49,12) 0.2728\r\n (32,49) 0.8346\r\n (28,72) 0.3244\r\n (27,74) 0.8721\r\n (7,85) 0.8113<\/div><\/div><\/div><\/div><\/div>
All GPU functions that can compute with <\/span>double<\/span> sparse have also had <\/span>single<\/span> sparse enabled.<\/span><\/div>
Let's transfer those 80,000 x 80,000 sparse matrices I created earlier onto the GPU<\/span><\/div>
randDoubleSparseGpu = gpuArray(randDoubleSparse);<\/span><\/span><\/div><\/div>
randSingleSparseGpu = gpuArray(randSingleSparse);<\/span><\/span><\/div><\/div><\/div>
and time how long it takes to multiply them together using <\/span>gputimeit<\/span><\/a>. I'll also time how long it takes to do this on the CPU for comparison<\/span><\/div>
singleCPUTime = timeit(@() randSingleSparse * randSingleSparse);<\/span><\/span><\/div><\/div>
doubleCPUTime = timeit(@() randDoubleSparse * randDoubleSparse);<\/span><\/span><\/div><\/div>
 <\/div><\/div>
singleGpuTime = gputimeit(@() randSingleSparseGpu * randSingleSparseGpu);<\/span><\/span><\/div><\/div>
doubleGpuTime = gputimeit(@() randDoubleSparseGpu * randDoubleSparseGpu);<\/span><\/span><\/div><\/div>
fprintf(<\/span>\"The CPU did the sparse double matrix multiplication in %.3fs\\n\" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"The CPU did the sparse single matrix multiplication in %.3fs\\n\\n\" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"The GPU did the sparse double matrix multiplication in %.3fs\\n\" <\/span>+ <\/span>...<\/span><\/span><\/div><\/div>
<\/span>\"The GPU did the sparse single matrix multiplication in %.3fs\\n\" <\/span>...<\/span><\/span><\/div><\/div>
,doubleCPUTime, singleCPUTime ,doubleGpuTime,singleGpuTime);<\/span><\/span><\/div>
The CPU did the sparse double matrix multiplication in 4.733s\r\nThe CPU did the sparse single matrix multiplication in 2.888s\r\n\r\nThe GPU did the sparse double matrix multiplication in 0.674s\r\nThe GPU did the sparse single matrix multiplication in 0.391s<\/div><\/div><\/div><\/div><\/div>
Not only is the GPU version of this computation much faster than the CPU version on my machine but you also see a speed-up when moving from <\/span>double<\/span> to <\/span>single<\/span> as you'd expect.<\/span><\/div>
Similarly, the team has added supported for <\/span>Distributed Arrays<\/span><\/a> so now you can create and use single precision sparse matrices that are so big you need to distribute them over multiple nodes of a High Performance Computing (HPC) cluster.<\/span><\/div>

Is single sparse one new feature or many new features?<\/span><\/h2>
While putting together this blog post, I found 4 entries in the Release Notes related to <\/span>single<\/span> sparse matrices in R2025a. <\/span>The first entry was in MATLAB itself <\/span><\/a>and referred to the fact that we now have them. Two entries <\/span>were for the GPU<\/span><\/a> and <\/span>Distributed Array support<\/span><\/a> discussed above from Parallel Computing Toolbox and one entry referred to calling <\/span>MATLAB from C++<\/span><\/a> since single-precision sparse matrices work there too now! <\/span><\/div>
That one entry in the MATLAB release notes mentioned the 6 creation functions that have been updated: <\/span>sparse<\/span>, <\/span>speye<\/span>, <\/span>spalloc<\/span>, <\/span>sprand<\/span>, <\/span>sprandn<\/span> and <\/span>sprandsym<\/span>. If I were the lead developer of this tranche of work I'd be arguing that I had at least 6 new features and not one.<\/span><\/div>
Actually, If I were the lead developer of this, I'd be arguing that this is dozens of new features because <\/span>all functions in MATLAB that support double-precision sparse matrices including elementary math, linear algebra, and sparse matrix functions<\/span> now also support <\/span>single<\/span> precision sparse matrices. All of those functions had to be modified, tested and get updated documentation.<\/span><\/div>
It's an astonishing amount of work. <\/span><\/div>
I think that this is also an illustration of why different people in MathWorks can give different feature counts when talking about new releases. Like all the truths we cling to, it depends on your point of view.<\/span><\/div>

More informative display for sparse matrices<\/span><\/h2>
Another feature that hasn't even been mentioned in the release notes is the improved display of sparse matrices. In R2024a and earlier, it looked like this<\/span><\/div>
sparse([0 0;0 0.2])<\/span><\/span><\/div>
ans =<\/span><\/span><\/div>
(2,2) 0.2000<\/span><\/span><\/div><\/div>
compared to the more informative<\/span><\/div>
sparse([0 0;0 0.2])<\/span><\/span><\/div>
ans = 2\u00d72 sparse double matrix (1 nonzero)<\/span><\/span><\/div>
(2,2) 0.2000\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
This was actually done in R2024b but it's even more meaningful now that single precision sparse matrices are possible.<\/span><\/div>

What happens when we open MAT files containing single sparse matrices in old versions of MATLAB<\/span><\/h2>
If you save a single-precision sparse matrix to a MAT file, you can load it into an earlier release of MATLAB. However, how the data is loaded depends on the release of MATLAB:<\/span><\/div>
  • MATLAB R2021b through R2024b \u2014 MATLAB warns that the data has an unsupported data type and loads it as a double-precision sparse matrix.<\/span><\/li><\/ul>
    % This line was run in <\/span>R2024b<\/span><\/span><\/div><\/div>
    load(<\/span>\"from25a.mat\"<\/span>)<\/span><\/span><\/div>
    Warning: Sparse matrix of unsupported datatype. Matrix has been converted to double.<\/div>
    <\/div><\/div><\/div><\/div><\/div><\/div>
    • MATLAB R2021a and earlier \u2014 MATLAB loads the data as a single-precision sparse matrix, but you cannot use the matrix because its data type is unsupported. Attempting to use the matrix can result in undefined behavior.<\/span><\/li><\/ul>

      Style tip: Use \"single\" and not 'single' when creating single sparse matrices<\/span><\/h2>
      MATLAB old-timers like me are often guilty of using character arrays such as <\/span>'single'<\/span> when we really should get with the times and use strings, i.e. \"<\/span>single\"<\/span>. We seem to get away with it too<\/span><\/div>
      smallSparse = sprand(50,100,0.001,<\/span>'single'<\/span>) <\/span>% Don't use 'single' like this<\/span><\/span><\/div>
      smallSparse = 50\u00d7100 sparse single matrix (5 nonzeros)<\/span><\/span><\/div>
      (22,28) 0.8777\r\n (42,71) 0.0741\r\n (24,80) 0.9256\r\n (37,82) 0.1663\r\n (18,89) 0.7241\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
      We really should be using strings though!<\/span><\/div>
      smallSparse = sprand(50,100,0.001,<\/span>\"single\"<\/span>) <\/span>% Using \"single\" is much better<\/span><\/span><\/div>
      smallSparse = 50\u00d7100 sparse single matrix (5 nonzeros)<\/span><\/span><\/div>
      (14,33) 0.8020\r\n (44,43) 0.8440\r\n (46,63) 0.3696\r\n (4,81) 0.9557\r\n (16,98) 0.7799\r\n<\/div><\/div><\/div><\/div><\/div><\/div>
      One good reason for this is so that the operation will fail more gracefully in older versions of MATLAB. Obviously, specifying the type of a <\/span>sparse<\/span> will fail in older versions of MATLAB since it wasn't supported but which type of failure would you prefer here?<\/span><\/div>
      % Run this line in <\/span>R2024b<\/span><\/span><\/div><\/div>
      smallSparse = sprand(50,100,0.001,<\/span>\"single\"<\/span>)<\/span><\/span><\/div>
      Error using <=
      Comparison between string and double is not supported.
      Error in sprand (line 61)
      if ~(rc <= 1 && rc >= 0 && imag(rc) == 0)<\/div>
      <\/div><\/div><\/div><\/div><\/div><\/div>
      We get an error message. Admittedly its a little confusing but since we couldn't go back in time and change this to something like <\/span>\"Choosing the data type for sparse is not supported\"<\/span> its a lot better than the alternative:<\/span><\/div>
      %Run this line in <\/span>R2024b<\/span><\/span><\/div><\/div>
      smallSparse = sprand(50,100,0.001,<\/span>'single'<\/span>)<\/span><\/span><\/div>
      smallSparse = <\/span><\/div>
      (34,41) 103\r\n (22,42) 110\r\n (40,49) 105\r\n (6,69) 101\r\n (32,73) 115\r\n (35,96) 108<\/div><\/div><\/div><\/div><\/div><\/div>
      When this first happened to me, it took a little bit of thought to figure out what was going on. When I say 'thought' I mean 'looking at the documentation' which explains the situation. There's a version of <\/span>sprand<\/span> that accepts 4 input arguments:<\/span><\/div>
      R = sprand(m,n,density,rc) creates <\/span>a matrix that also has reciprocal condition number approximately equal to rc. <\/span><\/span><\/div>
      The <\/span>matrix R is constructed from a sum of matrices of rank one.<\/span><\/span><\/div><\/div>
      If you give MATLAB a character array where it is expecting a numerical array, it converts it to its ASCII numerical equivalent:<\/span><\/div>
      double(<\/span>'single'<\/span>)<\/span><\/span><\/div>
      <\/div>
      <\/div>
      <\/div>
      <\/div>
      ans = <\/span>1\u00d76<\/span><\/div><\/div>
      115 105 110 103 108 101\r\n<\/div>
      <\/mw-icon><\/div>
      <\/mw-icon><\/div><\/div><\/div><\/div><\/div><\/div><\/div>
      This then gets used as the 4th input argument to <\/span>sprand<\/span> and weirdness ensues. <\/span><\/div>
      The fact that using <\/span>\"single\"<\/span> instead of <\/span>'single'<\/span> is useful here was not a design decision. It's just a concrete reason I discovered while writing this post to prefer the newer syntax. <\/span><\/div>
      My advice is always to use strings instead of character arrays whenever you can. It's newer and tends to be where development focuses its attention on these days.<\/span><\/div>

      Will you be using single precision sparse matrices?<\/span><\/h2>
      Many users have been asking for this functionality for a long time. Are you one of them? Will you be using these features? What is your application? Tell us all about it in the comments section.<\/span><\/div>\r\n<\/div>