using blaze::rowMajor;
using blaze::columnMajor;

// Serialization of both matrices
{
   blaze::StaticMatrix<double,3UL,5UL,rowMajor> D;
   blaze::CompressedMatrix<int,columnMajor> S;

   // ... Resizing and initialization

   // Creating an archive that writes into a the file "matrices.blaze"
   blaze::Archive<std::ofstream> archive( "matrices.blaze" );

   // Serialization of both matrices into the same archive. Note that D lies before S!
   archive << D << S;
}

// Reconstitution of both matrices
{
   blaze::DynamicMatrix<double,rowMajor> D1;
   blaze::DynamicMatrix<int,rowMajor> D2;

   // Creating an archive that reads from the file "matrices.blaze"
   blaze::Archive<std::ifstream> archive( "matrices.blaze" );

   // Reconstituting the former D matrix into D1. Note that it is possible to reconstitute
   // the matrix into a differrent kind of matrix (StaticMatrix -> DynamicMatrix), but that
   // the type of elements has to be the same.
   archive >> D1;

   // Reconstituting the former S matrix into D2. Note that is is even possible to reconstitute
   // a sparse matrix as a dense matrix (also the reverse is possible) and that a column-major
   // matrix can be reconstituted as row-major matrix (and vice versa). Note however that also
   // in this case the type of elements is the same!
   archive >> D2
}

// Serialization
{
   blaze::CompressedMatrix< blaze::DynamicMatrix< blaze::complex<double> > > mat;

   // ... Resizing and initialization

   // Creating an archive that writes into a the file "matrix.blaze"
   blaze::Archive<std::ofstream> archive( "matrix.blaze" );

   // Serialization of the matrix into the archive
   archive << mat;
}

// Deserialization
{
   blaze::CompressedMatrix< blaze::DynamicMatrix< blaze::complex<double> > > mat;

   // Creating an archive that reads from the file "matrix.blaze"
   blaze::Archive<std::ifstream> archive( "matrix.blaze" );

   // Reconstitution of the matrix from the archive
   archive >> mat;
}