- Main Page
- Related Pages
- Classes
- Files

- File List

# io.hpp

    00001 //
    00002 //  Copyright (c) 2000-2010
    00003 //  Joerg Walter, Mathias Koch, David Bellot
    00004 //
    00005 //  Distributed under the Boost Software License, Version 1.0. (See
    00006 //  accompanying file LICENSE_1_0.txt or copy at
    00007 //  http://www.boost.org/LICENSE_1_0.txt)
    00008 //
    00009 //  The authors gratefully acknowledge the support of
    00010 //  GeNeSys mbH & Co. KG in producing this work.
    00011 //
    00012
    00013 #ifndef _BOOST_UBLAS_IO_
    00014 #define _BOOST_UBLAS_IO_
    00015
    00016 // Only forward definition required to define stream operations
    00017 #include <iosfwd>
    00018 #include <sstream>
    00019 #include <boost/numeric/ublas/matrix_expression.hpp>
    00020
    00021
    00022 namespace boost { namespace numeric { namespace ublas {
    00023
    00046     template<class E, class T, class VE>
    00047     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
    00048     std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
    00049                                            const vector_expression<VE> &v) {
    00050         typedef typename VE::size_type size_type;
    00051         size_type size = v ().size ();
    00052         std::basic_ostringstream<E, T, std::allocator<E> > s;
    00053         s.flags (os.flags ());
    00054         s.imbue (os.getloc ());
    00055         s.precision (os.precision ());
    00056         s << '[' << size << "](";
    00057         if (size > 0)
    00058             s << v () (0);
    00059         for (size_type i = 1; i < size; ++ i)
    00060             s << ',' << v () (i);
    00061         s << ')';
    00062         return os << s.str ().c_str ();
    00063     }
    00064
    00087     template<class E, class T, class VT, class VA>
    00088     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
    00089     std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
    00090                                            vector<VT, VA> &v) {
    00091         typedef typename vector<VT, VA>::size_type size_type;
    00092         E ch;
    00093         size_type size;
    00094         if (is >> ch && ch != '[') {
    00095             is.putback (ch);
    00096             is.setstate (std::ios_base::failbit);
    00097         } else if (is >> size >> ch && ch != ']') {
    00098             is.putback (ch);
    00099             is.setstate (std::ios_base::failbit);
    00100         } else if (! is.fail ()) {
    00101             vector<VT, VA> s (size);
    00102             if (is >> ch && ch != '(') {
    00103                 is.putback (ch);
    00104                 is.setstate (std::ios_base::failbit);
    00105             } else if (! is.fail ()) {
    00106                 for (size_type i = 0; i < size; i ++) {
    00107                     if (is >> s (i) >> ch && ch != ',') {
    00108                         is.putback (ch);
    00109                         if (i < size - 1)
    00110                             is.setstate (std::ios_base::failbit);
    00111                         break;
    00112                     }
    00113                 }
    00114                 if (is >> ch && ch != ')') {
    00115                     is.putback (ch);
    00116                     is.setstate (std::ios_base::failbit);
    00117                 }
    00118             }
    00119             if (! is.fail ())
    00120                 v.swap (s);
    00121         }
    00122         return is;
    00123     }
    00124
    00148     template<class E, class T, class ME>
    00149     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
    00150     std::basic_ostream<E, T> &operator << (std::basic_ostream<E, T> &os,
    00151                                            const matrix_expression<ME> &m) {
    00152         typedef typename ME::size_type size_type;
    00153         size_type size1 = m ().size1 ();
    00154         size_type size2 = m ().size2 ();
    00155         std::basic_ostringstream<E, T, std::allocator<E> > s;
    00156         s.flags (os.flags ());
    00157         s.imbue (os.getloc ());
    00158         s.precision (os.precision ());
    00159         s << '[' << size1 << ',' << size2 << "](";
    00160         if (size1 > 0) {
    00161             s << '(' ;
    00162             if (size2 > 0)
    00163                 s << m () (0, 0);
    00164             for (size_type j = 1; j < size2; ++ j)
    00165                 s << ',' << m () (0, j);
    00166             s << ')';
    00167         }
    00168         for (size_type i = 1; i < size1; ++ i) {
    00169             s << ",(" ;
    00170             if (size2 > 0)
    00171                 s << m () (i, 0);
    00172             for (size_type j = 1; j < size2; ++ j)
    00173                 s << ',' << m () (i, j);
    00174             s << ')';
    00175         }
    00176         s << ')';
    00177         return os << s.str ().c_str ();
    00178     }
    00179
    00199     template<class E, class T, class MT, class MF, class MA>
    00200     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
    00201     std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
    00202                                            matrix<MT, MF, MA> &m) {
    00203         typedef typename matrix<MT, MF, MA>::size_type size_type;
    00204         E ch;
    00205         size_type size1, size2;
    00206         if (is >> ch && ch != '[') {
    00207             is.putback (ch);
    00208             is.setstate (std::ios_base::failbit);
    00209         } else if (is >> size1 >> ch && ch != ',') {
    00210             is.putback (ch);
    00211             is.setstate (std::ios_base::failbit);
    00212         } else if (is >> size2 >> ch && ch != ']') {
    00213             is.putback (ch);
    00214             is.setstate (std::ios_base::failbit);
    00215         } else if (! is.fail ()) {
    00216             matrix<MT, MF, MA> s (size1, size2);
    00217             if (is >> ch && ch != '(') {
    00218                 is.putback (ch);
    00219                 is.setstate (std::ios_base::failbit);
    00220             } else if (! is.fail ()) {
    00221                 for (size_type i = 0; i < size1; i ++) {
    00222                     if (is >> ch && ch != '(') {
    00223                         is.putback (ch);
    00224                         is.setstate (std::ios_base::failbit);
    00225                         break;
    00226                     }
    00227                     for (size_type j = 0; j < size2; j ++) {
    00228                         if (is >> s (i, j) >> ch && ch != ',') {
    00229                             is.putback (ch);
    00230                             if (j < size2 - 1) {
    00231                                 is.setstate (std::ios_base::failbit);
    00232                                 break;
    00233                             }
    00234                         }
    00235                     }
    00236                     if (is >> ch && ch != ')') {
    00237                         is.putback (ch);
    00238                         is.setstate (std::ios_base::failbit);
    00239                         break;
    00240                     }
    00241                     if (is >> ch && ch != ',') {
    00242                        is.putback (ch);
    00243                        if (i < size1 - 1) {
    00244                             is.setstate (std::ios_base::failbit);
    00245                             break;
    00246                        }
    00247                     }
    00248                 }
    00249                 if (is >> ch && ch != ')') {
    00250                     is.putback (ch);
    00251                     is.setstate (std::ios_base::failbit);
    00252                 }
    00253             }
    00254             if (! is.fail ())
    00255                 m.swap (s);
    00256         }
    00257         return is;
    00258     }
    00259
    00281     template<class E, class T, class MT, class MF1, class MF2, class MA>
    00282     // BOOST_UBLAS_INLINE This function seems to be big. So we do not let the compiler inline it.
    00283     std::basic_istream<E, T> &operator >> (std::basic_istream<E, T> &is,
    00284                                            symmetric_matrix<MT, MF1, MF2, MA> &m) {
    00285         typedef typename symmetric_matrix<MT, MF1, MF2, MA>::size_type size_type;
    00286         E ch;
    00287         size_type size1, size2;
    00288         MT value;
    00289         if (is >> ch && ch != '[') {
    00290             is.putback (ch);
    00291             is.setstate (std::ios_base::failbit);
    00292         } else if (is >> size1 >> ch && ch != ',') {
    00293             is.putback (ch);
    00294             is.setstate (std::ios_base::failbit);
    00295         } else if (is >> size2 >> ch && (size2 != size1 || ch != ']')) { // symmetric matrix must be square
    00296             is.putback (ch);
    00297             is.setstate (std::ios_base::failbit);
    00298         } else if (! is.fail ()) {
    00299             symmetric_matrix<MT, MF1, MF2, MA> s (size1, size2);
    00300             if (is >> ch && ch != '(') {
    00301                 is.putback (ch);
    00302                 is.setstate (std::ios_base::failbit);
    00303              } else if (! is.fail ()) {
    00304                 for (size_type i = 0; i < size1; i ++) {
    00305                     if (is >> ch && ch != '(') {
    00306                         is.putback (ch);
    00307                         is.setstate (std::ios_base::failbit);
    00308                         break;
    00309                     }
    00310                     for (size_type j = 0; j < size2; j ++) {
    00311                         if (is >> value >> ch && ch != ',') {
    00312                             is.putback (ch);
    00313                             if (j < size2 - 1) {
    00314                                 is.setstate (std::ios_base::failbit);
    00315                                 break;
    00316                             }
    00317                         }
    00318                         if (i <= j) {
    00319                              // this is the first time we read this element - set the value
    00320                             s(i,j) = value;
    00321                         }
    00322                         else if ( s(i,j) != value ) {
    00323                             // matrix is not symmetric
    00324                             is.setstate (std::ios_base::failbit);
    00325                             break;
    00326                         }
    00327                      }
    00328                      if (is >> ch && ch != ')') {
    00329                          is.putback (ch);
    00330                          is.setstate (std::ios_base::failbit);
    00331                          break;
    00332                      }
    00333                      if (is >> ch && ch != ',') {
    00334                         is.putback (ch);
    00335                         if (i < size1 - 1) {
    00336                              is.setstate (std::ios_base::failbit);
    00337                              break;
    00338                         }
    00339                      }
    00340                 }
    00341                 if (is >> ch && ch != ')') {
    00342                     is.putback (ch);
    00343                     is.setstate (std::ios_base::failbit);
    00344                 }
    00345             }
    00346             if (! is.fail ())
    00347                 m.swap (s);
    00348         }
    00349         return is;
    00350     }
    00351
    00352
    00353 }}}
    00354
    00355 #endif