ceph/src/boost/libs/numeric/ublas/include/boost/numeric/ublas/detail/raw.hpp

   1 //
   2 //  Copyright (c) 2002-2003
   3 //  Toon Knapen, Kresimir Fresl, Joerg Walter
   4 //
   5 //  Distributed under the Boost Software License, Version 1.0. (See
   6 //  accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 //
  10
  11 #ifndef _BOOST_UBLAS_RAW_
  12 #define _BOOST_UBLAS_RAW_
  13
  14 namespace boost { namespace numeric { namespace ublas { namespace raw {
  15
  16     // We need data_const() mostly due to MSVC 6.0.
  17     // But how shall we write portable code otherwise?
  18
  19     template < typename V >
  20     BOOST_UBLAS_INLINE
  21     int size( const V &v ) ;
  22
  23     template < typename V >
  24     BOOST_UBLAS_INLINE
  25     int size( const vector_reference<V> &v ) ;
  26
  27     template < typename M >
  28     BOOST_UBLAS_INLINE
  29     int size1( const M &m ) ;
  30     template < typename M >
  31     BOOST_UBLAS_INLINE
  32     int size2( const M &m ) ;
  33
  34     template < typename M >
  35     BOOST_UBLAS_INLINE
  36     int size1( const matrix_reference<M> &m ) ;
  37     template < typename M >
  38     BOOST_UBLAS_INLINE
  39     int size2( const matrix_reference<M> &m ) ;
  40
  41     template < typename M >
  42     BOOST_UBLAS_INLINE
  43     int leading_dimension( const M &m, row_major_tag ) ;
  44     template < typename M >
  45     BOOST_UBLAS_INLINE
  46     int leading_dimension( const M &m, column_major_tag ) ;
  47     template < typename M >
  48     BOOST_UBLAS_INLINE
  49     int leading_dimension( const M &m ) ;
  50
  51     template < typename M >
  52     BOOST_UBLAS_INLINE
  53     int leading_dimension( const matrix_reference<M> &m ) ;
  54
  55     template < typename V >
  56     BOOST_UBLAS_INLINE
  57     int stride( const V &v ) ;
  58
  59     template < typename V >
  60     BOOST_UBLAS_INLINE
  61     int stride( const vector_range<V> &v ) ;
  62     template < typename V >
  63     BOOST_UBLAS_INLINE
  64     int stride( const vector_slice<V> &v ) ;
  65
  66     template < typename M >
  67     BOOST_UBLAS_INLINE
  68     int stride( const matrix_row<M> &v ) ;
  69     template < typename M >
  70     BOOST_UBLAS_INLINE
  71     int stride( const matrix_column<M> &v ) ;
  72
  73     template < typename M >
  74     BOOST_UBLAS_INLINE
  75     int stride1( const M &m ) ;
  76     template < typename M >
  77     BOOST_UBLAS_INLINE
  78     int stride2( const M &m ) ;
  79
  80     template < typename M >
  81     BOOST_UBLAS_INLINE
  82     int stride1( const matrix_reference<M> &m ) ;
  83     template < typename M >
  84     BOOST_UBLAS_INLINE
  85     int stride2( const matrix_reference<M> &m ) ;
  86
  87     template < typename T, std::size_t M, std::size_t N >
  88     BOOST_UBLAS_INLINE
  89     int stride1( const c_matrix<T, M, N> &m ) ;
  90     template < typename T, std::size_t M, std::size_t N >
  91     BOOST_UBLAS_INLINE
  92     int stride2( const c_matrix<T, M, N> &m ) ;
  93
  94     template < typename M >
  95     BOOST_UBLAS_INLINE
  96     int stride1( const matrix_range<M> &m ) ;
  97     template < typename M >
  98     BOOST_UBLAS_INLINE
  99     int stride1( const matrix_slice<M> &m ) ;
 100     template < typename M >
 101     BOOST_UBLAS_INLINE
 102     int stride2( const matrix_range<M> &m ) ;
 103     template < typename M >
 104     BOOST_UBLAS_INLINE
 105     int stride2( const matrix_slice<M> &m ) ;
 106
 107     template < typename MV >
 108     BOOST_UBLAS_INLINE
 109     typename MV::array_type::array_type::const_pointer data( const MV &mv ) ;
 110     template < typename MV >
 111     BOOST_UBLAS_INLINE
 112     typename MV::array_type::array_type::const_pointer data_const( const MV &mv ) ;
 113     template < typename MV >
 114     BOOST_UBLAS_INLINE
 115     typename MV::array_type::pointer data( MV &mv ) ;
 116
 117     template < typename V >
 118     BOOST_UBLAS_INLINE
 119     typename V::array_type::array_type::const_pointer data( const vector_reference<V> &v ) ;
 120     template < typename V >
 121     BOOST_UBLAS_INLINE
 122     typename V::array_type::array_type::const_pointer data_const( const vector_reference<V> &v ) ;
 123     template < typename V >
 124     BOOST_UBLAS_INLINE
 125     typename V::array_type::pointer data( vector_reference<V> &v ) ;
 126
 127     template < typename T, std::size_t N >
 128     BOOST_UBLAS_INLINE
 129     typename c_vector<T, N>::array_type::array_type::const_pointer data( const c_vector<T, N> &v ) ;
 130     template < typename T, std::size_t N >
 131     BOOST_UBLAS_INLINE
 132     typename c_vector<T, N>::array_type::array_type::const_pointer data_const( const c_vector<T, N> &v ) ;
 133     template < typename T, std::size_t N >
 134     BOOST_UBLAS_INLINE
 135     typename c_vector<T, N>::pointer data( c_vector<T, N> &v ) ;
 136
 137     template < typename V >
 138     BOOST_UBLAS_INLINE
 139     typename V::array_type::array_type::const_pointer data( const vector_range<V> &v ) ;
 140     template < typename V >
 141     BOOST_UBLAS_INLINE
 142     typename V::array_type::array_type::const_pointer data( const vector_slice<V> &v ) ;
 143     template < typename V >
 144     BOOST_UBLAS_INLINE
 145     typename V::array_type::array_type::const_pointer data_const( const vector_range<V> &v ) ;
 146     template < typename V >
 147     BOOST_UBLAS_INLINE
 148     typename V::array_type::array_type::const_pointer data_const( const vector_slice<V> &v ) ;
 149     template < typename V >
 150     BOOST_UBLAS_INLINE
 151     typename V::array_type::pointer data( vector_range<V> &v ) ;
 152     template < typename V >
 153     BOOST_UBLAS_INLINE
 154     typename V::array_type::pointer data( vector_slice<V> &v ) ;
 155
 156     template < typename M >
 157     BOOST_UBLAS_INLINE
 158     typename M::array_type::array_type::const_pointer data( const matrix_reference<M> &m ) ;
 159     template < typename M >
 160     BOOST_UBLAS_INLINE
 161     typename M::array_type::array_type::const_pointer data_const( const matrix_reference<M> &m ) ;
 162     template < typename M >
 163     BOOST_UBLAS_INLINE
 164     typename M::array_type::pointer data( matrix_reference<M> &m ) ;
 165
 166     template < typename T, std::size_t M, std::size_t N >
 167     BOOST_UBLAS_INLINE
 168     typename c_matrix<T, M, N>::array_type::array_type::const_pointer data( const c_matrix<T, M, N> &m ) ;
 169     template < typename T, std::size_t M, std::size_t N >
 170     BOOST_UBLAS_INLINE
 171     typename c_matrix<T, M, N>::array_type::array_type::const_pointer data_const( const c_matrix<T, M, N> &m ) ;
 172     template < typename T, std::size_t M, std::size_t N >
 173     BOOST_UBLAS_INLINE
 174     typename c_matrix<T, M, N>::pointer data( c_matrix<T, M, N> &m ) ;
 175
 176     template < typename M >
 177     BOOST_UBLAS_INLINE
 178     typename M::array_type::array_type::const_pointer data( const matrix_row<M> &v ) ;
 179     template < typename M >
 180     BOOST_UBLAS_INLINE
 181     typename M::array_type::array_type::const_pointer data( const matrix_column<M> &v ) ;
 182     template < typename M >
 183     BOOST_UBLAS_INLINE
 184     typename M::array_type::array_type::const_pointer data_const( const matrix_row<M> &v ) ;
 185     template < typename M >
 186     BOOST_UBLAS_INLINE
 187     typename M::array_type::array_type::const_pointer data_const( const matrix_column<M> &v ) ;
 188     template < typename M >
 189     BOOST_UBLAS_INLINE
 190     typename M::array_type::pointer data( matrix_row<M> &v ) ;
 191     template < typename M >
 192     BOOST_UBLAS_INLINE
 193     typename M::array_type::pointer data( matrix_column<M> &v ) ;
 194
 195     template < typename M >
 196     BOOST_UBLAS_INLINE
 197     typename M::array_type::array_type::const_pointer data( const matrix_range<M> &m ) ;
 198     template < typename M >
 199     BOOST_UBLAS_INLINE
 200     typename M::array_type::array_type::const_pointer data( const matrix_slice<M> &m ) ;
 201     template < typename M >
 202     BOOST_UBLAS_INLINE
 203     typename M::array_type::array_type::const_pointer data_const( const matrix_range<M> &m ) ;
 204     template < typename M >
 205     BOOST_UBLAS_INLINE
 206     typename M::array_type::array_type::const_pointer data_const( const matrix_slice<M> &m ) ;
 207     template < typename M >
 208     BOOST_UBLAS_INLINE
 209     typename M::array_type::pointer data( matrix_range<M> &m ) ;
 210     template < typename M >
 211     BOOST_UBLAS_INLINE
 212     typename M::array_type::pointer data( matrix_slice<M> &m ) ;
 213
 214     template < typename MV >
 215     BOOST_UBLAS_INLINE
 216     typename MV::array_type::array_type::const_pointer base( const MV &mv ) ;
 217
 218     template < typename MV >
 219     BOOST_UBLAS_INLINE
 220     typename MV::array_type::array_type::const_pointer base_const( const MV &mv ) ;
 221     template < typename MV >
 222     BOOST_UBLAS_INLINE
 223     typename MV::array_type::pointer base( MV &mv ) ;
 224
 225     template < typename V >
 226     BOOST_UBLAS_INLINE
 227     typename V::array_type::array_type::const_pointer base( const vector_reference<V> &v ) ;
 228     template < typename V >
 229     BOOST_UBLAS_INLINE
 230     typename V::array_type::array_type::const_pointer base_const( const vector_reference<V> &v ) ;
 231     template < typename V >
 232     BOOST_UBLAS_INLINE
 233     typename V::array_type::pointer base( vector_reference<V> &v ) ;
 234
 235     template < typename T, std::size_t N >
 236     BOOST_UBLAS_INLINE
 237     typename c_vector<T, N>::array_type::array_type::const_pointer base( const c_vector<T, N> &v ) ;
 238     template < typename T, std::size_t N >
 239     BOOST_UBLAS_INLINE
 240     typename c_vector<T, N>::array_type::array_type::const_pointer base_const( const c_vector<T, N> &v ) ;
 241     template < typename T, std::size_t N >
 242     BOOST_UBLAS_INLINE
 243     typename c_vector<T, N>::pointer base( c_vector<T, N> &v ) ;
 244
 245     template < typename V >
 246     BOOST_UBLAS_INLINE
 247     typename V::array_type::array_type::const_pointer base( const vector_range<V> &v ) ;
 248     template < typename V >
 249     BOOST_UBLAS_INLINE
 250     typename V::array_type::array_type::const_pointer base( const vector_slice<V> &v ) ;
 251     template < typename V >
 252     BOOST_UBLAS_INLINE
 253     typename V::array_type::array_type::const_pointer base_const( const vector_range<V> &v ) ;
 254     template < typename V >
 255     BOOST_UBLAS_INLINE
 256     typename V::array_type::array_type::const_pointer base_const( const vector_slice<V> &v ) ;
 257     template < typename V >
 258     BOOST_UBLAS_INLINE
 259     typename V::array_type::pointer base( vector_range<V> &v ) ;
 260     template < typename V >
 261     BOOST_UBLAS_INLINE
 262     typename V::array_type::pointer base( vector_slice<V> &v ) ;
 263
 264     template < typename M >
 265     BOOST_UBLAS_INLINE
 266     typename M::array_type::array_type::const_pointer base( const matrix_reference<M> &m ) ;
 267     template < typename M >
 268     BOOST_UBLAS_INLINE
 269     typename M::array_type::array_type::const_pointer base_const( const matrix_reference<M> &m ) ;
 270     template < typename M >
 271     BOOST_UBLAS_INLINE
 272     typename M::array_type::pointer base( matrix_reference<M> &m ) ;
 273
 274     template < typename T, std::size_t M, std::size_t N >
 275     BOOST_UBLAS_INLINE
 276     typename c_matrix<T, M, N>::array_type::array_type::const_pointer base( const c_matrix<T, M, N> &m ) ;
 277     template < typename T, std::size_t M, std::size_t N >
 278     BOOST_UBLAS_INLINE
 279     typename c_matrix<T, M, N>::array_type::array_type::const_pointer base_const( const c_matrix<T, M, N> &m ) ;
 280     template < typename T, std::size_t M, std::size_t N >
 281     BOOST_UBLAS_INLINE
 282     typename c_matrix<T, M, N>::pointer base( c_matrix<T, M, N> &m ) ;
 283
 284     template < typename M >
 285     BOOST_UBLAS_INLINE
 286     typename M::array_type::array_type::const_pointer base( const matrix_row<M> &v ) ;
 287     template < typename M >
 288     BOOST_UBLAS_INLINE
 289     typename M::array_type::array_type::const_pointer base( const matrix_column<M> &v ) ;
 290     template < typename M >
 291     BOOST_UBLAS_INLINE
 292     typename M::array_type::array_type::const_pointer base_const( const matrix_row<M> &v ) ;
 293     template < typename M >
 294     BOOST_UBLAS_INLINE
 295     typename M::array_type::array_type::const_pointer base_const( const matrix_column<M> &v ) ;
 296     template < typename M >
 297     BOOST_UBLAS_INLINE
 298     typename M::array_type::pointer base( matrix_row<M> &v ) ;
 299     template < typename M >
 300     BOOST_UBLAS_INLINE
 301     typename M::array_type::pointer base( matrix_column<M> &v ) ;
 302
 303     template < typename M >
 304     BOOST_UBLAS_INLINE
 305     typename M::array_type::array_type::const_pointer base( const matrix_range<M> &m ) ;
 306     template < typename M >
 307     BOOST_UBLAS_INLINE
 308     typename M::array_type::array_type::const_pointer base( const matrix_slice<M> &m ) ;
 309     template < typename M >
 310     BOOST_UBLAS_INLINE
 311     typename M::array_type::array_type::const_pointer base_const( const matrix_range<M> &m ) ;
 312     template < typename M >
 313     BOOST_UBLAS_INLINE
 314     typename M::array_type::array_type::const_pointer base_const( const matrix_slice<M> &m ) ;
 315     template < typename M >
 316     BOOST_UBLAS_INLINE
 317     typename M::array_type::pointer base( matrix_range<M> &m ) ;
 318     template < typename M >
 319     BOOST_UBLAS_INLINE
 320     typename M::array_type::pointer base( matrix_slice<M> &m ) ;
 321
 322     template < typename MV >
 323     BOOST_UBLAS_INLINE
 324     typename MV::size_type start( const MV &mv ) ;
 325
 326     template < typename V >
 327     BOOST_UBLAS_INLINE
 328     typename V::size_type start( const vector_range<V> &v ) ;
 329     template < typename V >
 330     BOOST_UBLAS_INLINE
 331     typename V::size_type start( const vector_slice<V> &v ) ;
 332
 333     template < typename M >
 334     BOOST_UBLAS_INLINE
 335     typename M::size_type start( const matrix_row<M> &v ) ;
 336     template < typename M >
 337     BOOST_UBLAS_INLINE
 338     typename M::size_type start( const matrix_column<M> &v ) ;
 339
 340     template < typename M >
 341     BOOST_UBLAS_INLINE
 342     typename M::size_type start( const matrix_range<M> &m ) ;
 343     template < typename M >
 344     BOOST_UBLAS_INLINE
 345     typename M::size_type start( const matrix_slice<M> &m ) ;
 346
 347
 348
 349     template < typename V >
 350     BOOST_UBLAS_INLINE
 351     int size( const V &v ) {
 352         return v.size() ;
 353     }
 354
 355     template < typename V >
 356     BOOST_UBLAS_INLINE
 357     int size( const vector_reference<V> &v ) {
 358         return size( v ) ;
 359     }
 360
 361     template < typename M >
 362     BOOST_UBLAS_INLINE
 363     int size1( const M &m ) {
 364         return m.size1() ;
 365     }
 366     template < typename M >
 367     BOOST_UBLAS_INLINE
 368     int size2( const M &m ) {
 369         return m.size2() ;
 370     }
 371
 372     template < typename M >
 373     BOOST_UBLAS_INLINE
 374     int size1( const matrix_reference<M> &m ) {
 375         return size1( m.expression() ) ;
 376     }
 377     template < typename M >
 378     BOOST_UBLAS_INLINE
 379     int size2( const matrix_reference<M> &m ) {
 380         return size2( m.expression() ) ;
 381     }
 382
 383     template < typename M >
 384     BOOST_UBLAS_INLINE
 385     int leading_dimension( const M &m, row_major_tag ) {
 386         return m.size2() ;
 387     }
 388     template < typename M >
 389     BOOST_UBLAS_INLINE
 390     int leading_dimension( const M &m, column_major_tag ) {
 391         return m.size1() ;
 392     }
 393     template < typename M >
 394     BOOST_UBLAS_INLINE
 395     int leading_dimension( const M &m ) {
 396         return leading_dimension( m, typename M::orientation_category() ) ;
 397     }
 398
 399     template < typename M >
 400     BOOST_UBLAS_INLINE
 401     int leading_dimension( const matrix_reference<M> &m ) {
 402         return leading_dimension( m.expression() ) ;
 403     }
 404
 405     template < typename V >
 406     BOOST_UBLAS_INLINE
 407     int stride( const V &v ) {
 408         return 1 ;
 409     }
 410
 411     template < typename V >
 412     BOOST_UBLAS_INLINE
 413     int stride( const vector_range<V> &v ) {
 414         return stride( v.data() ) ;
 415     }
 416     template < typename V >
 417     BOOST_UBLAS_INLINE
 418     int stride( const vector_slice<V> &v ) {
 419         return v.stride() * stride( v.data() ) ;
 420     }
 421
 422     template < typename M >
 423     BOOST_UBLAS_INLINE
 424     int stride( const matrix_row<M> &v ) {
 425         return stride2( v.data() ) ;
 426     }
 427     template < typename M >
 428     BOOST_UBLAS_INLINE
 429     int stride( const matrix_column<M> &v ) {
 430         return stride1( v.data() ) ;
 431     }
 432
 433     template < typename M >
 434     BOOST_UBLAS_INLINE
 435     int stride1( const M &m ) {
 436         typedef typename M::functor_type functor_type;
 437         return functor_type::one1( m.size1(), m.size2() ) ;
 438     }
 439     template < typename M >
 440     BOOST_UBLAS_INLINE
 441     int stride2( const M &m ) {
 442         typedef typename M::functor_type functor_type;
 443         return functor_type::one2( m.size1(), m.size2() ) ;
 444     }
 445
 446     template < typename M >
 447     BOOST_UBLAS_INLINE
 448     int stride1( const matrix_reference<M> &m ) {
 449         return stride1( m.expression() ) ;
 450     }
 451     template < typename M >
 452     BOOST_UBLAS_INLINE
 453     int stride2( const matrix_reference<M> &m ) {
 454         return stride2( m.expression() ) ;
 455     }
 456
 457     template < typename T, std::size_t M, std::size_t N >
 458     BOOST_UBLAS_INLINE
 459     int stride1( const c_matrix<T, M, N> &m ) {
 460         return N ;
 461     }
 462     template < typename T, std::size_t M, std::size_t N >
 463     BOOST_UBLAS_INLINE
 464     int stride2( const c_matrix<T, M, N> &m ) {
 465         return 1 ;
 466     }
 467
 468     template < typename M >
 469     BOOST_UBLAS_INLINE
 470     int stride1( const matrix_range<M> &m ) {
 471         return stride1( m.data() ) ;
 472     }
 473     template < typename M >
 474     BOOST_UBLAS_INLINE
 475     int stride1( const matrix_slice<M> &m ) {
 476         return m.stride1() * stride1( m.data() ) ;
 477     }
 478     template < typename M >
 479     BOOST_UBLAS_INLINE
 480     int stride2( const matrix_range<M> &m ) {
 481         return stride2( m.data() ) ;
 482     }
 483     template < typename M >
 484     BOOST_UBLAS_INLINE
 485     int stride2( const matrix_slice<M> &m ) {
 486         return m.stride2() * stride2( m.data() ) ;
 487     }
 488
 489     template < typename MV >
 490     BOOST_UBLAS_INLINE
 491     typename MV::array_type::array_type::array_type::const_pointer data( const MV &mv ) {
 492         return &mv.data().begin()[0] ;
 493     }
 494     template < typename MV >
 495     BOOST_UBLAS_INLINE
 496     typename MV::array_type::array_type::const_pointer data_const( const MV &mv ) {
 497         return &mv.data().begin()[0] ;
 498     }
 499     template < typename MV >
 500     BOOST_UBLAS_INLINE
 501     typename MV::array_type::pointer data( MV &mv ) {
 502         return &mv.data().begin()[0] ;
 503     }
 504
 505
 506     template < typename V >
 507     BOOST_UBLAS_INLINE
 508     typename V::array_type::array_type::const_pointer data( const vector_reference<V> &v ) {
 509         return data( v.expression () ) ;
 510     }
 511     template < typename V >
 512     BOOST_UBLAS_INLINE
 513     typename V::array_type::array_type::const_pointer data_const( const vector_reference<V> &v ) {
 514         return data_const( v.expression () ) ;
 515     }
 516     template < typename V >
 517     BOOST_UBLAS_INLINE
 518     typename V::array_type::pointer data( vector_reference<V> &v ) {
 519         return data( v.expression () ) ;
 520     }
 521
 522     template < typename T, std::size_t N >
 523     BOOST_UBLAS_INLINE
 524     typename c_vector<T, N>::array_type::array_type::const_pointer data( const c_vector<T, N> &v ) {
 525         return v.data() ;
 526     }
 527     template < typename T, std::size_t N >
 528     BOOST_UBLAS_INLINE
 529     typename c_vector<T, N>::array_type::array_type::const_pointer data_const( const c_vector<T, N> &v ) {
 530         return v.data() ;
 531     }
 532     template < typename T, std::size_t N >
 533     BOOST_UBLAS_INLINE
 534     typename c_vector<T, N>::pointer data( c_vector<T, N> &v ) {
 535         return v.data() ;
 536     }
 537
 538     template < typename V >
 539     BOOST_UBLAS_INLINE
 540     typename V::array_type::array_type::const_pointer data( const vector_range<V> &v ) {
 541         return data( v.data() ) + v.start() * stride (v.data() ) ;
 542     }
 543     template < typename V >
 544     BOOST_UBLAS_INLINE
 545     typename V::array_type::array_type::const_pointer data( const vector_slice<V> &v ) {
 546         return data( v.data() ) + v.start() * stride (v.data() ) ;
 547     }
 548     template < typename V >
 549     BOOST_UBLAS_INLINE
 550     typename V::array_type::array_type::const_pointer data_const( const vector_range<V> &v ) {
 551         return data_const( v.data() ) + v.start() * stride (v.data() ) ;
 552     }
 553     template < typename V >
 554     BOOST_UBLAS_INLINE
 555     typename V::array_type::const_pointer data_const( const vector_slice<V> &v ) {
 556         return data_const( v.data() ) + v.start() * stride (v.data() ) ;
 557     }
 558     template < typename V >
 559     BOOST_UBLAS_INLINE
 560     typename V::array_type::pointer data( vector_range<V> &v ) {
 561         return data( v.data() ) + v.start() * stride (v.data() ) ;
 562     }
 563     template < typename V >
 564     BOOST_UBLAS_INLINE
 565     typename V::array_type::pointer data( vector_slice<V> &v ) {
 566         return data( v.data() ) + v.start() * stride (v.data() ) ;
 567     }
 568
 569     template < typename M >
 570     BOOST_UBLAS_INLINE
 571     typename M::array_type::const_pointer data( const matrix_reference<M> &m ) {
 572         return data( m.expression () ) ;
 573     }
 574     template < typename M >
 575     BOOST_UBLAS_INLINE
 576     typename M::array_type::const_pointer data_const( const matrix_reference<M> &m ) {
 577         return data_const( m.expression () ) ;
 578     }
 579     template < typename M >
 580     BOOST_UBLAS_INLINE
 581     typename M::array_type::pointer data( matrix_reference<M> &m ) {
 582         return data( m.expression () ) ;
 583     }
 584
 585     template < typename T, std::size_t M, std::size_t N >
 586     BOOST_UBLAS_INLINE
 587     typename c_matrix<T, M, N>::array_type::const_pointer data( const c_matrix<T, M, N> &m ) {
 588         return m.data() ;
 589     }
 590     template < typename T, std::size_t M, std::size_t N >
 591     BOOST_UBLAS_INLINE
 592     typename c_matrix<T, M, N>::array_type::const_pointer data_const( const c_matrix<T, M, N> &m ) {
 593         return m.data() ;
 594     }
 595     template < typename T, std::size_t M, std::size_t N >
 596     BOOST_UBLAS_INLINE
 597     typename c_matrix<T, M, N>::pointer data( c_matrix<T, M, N> &m ) {
 598         return m.data() ;
 599     }
 600
 601     template < typename M >
 602     BOOST_UBLAS_INLINE
 603     typename M::array_type::const_pointer data( const matrix_row<M> &v ) {
 604         return data( v.data() ) + v.index() * stride1( v.data() ) ;
 605     }
 606     template < typename M >
 607     BOOST_UBLAS_INLINE
 608     typename M::array_type::const_pointer data( const matrix_column<M> &v ) {
 609         return data( v.data() ) + v.index() * stride2( v.data() ) ;
 610     }
 611     template < typename M >
 612     BOOST_UBLAS_INLINE
 613     typename M::array_type::const_pointer data_const( const matrix_row<M> &v ) {
 614         return data_const( v.data() ) + v.index() * stride1( v.data() ) ;
 615     }
 616     template < typename M >
 617     BOOST_UBLAS_INLINE
 618     typename M::array_type::const_pointer data_const( const matrix_column<M> &v ) {
 619         return data_const( v.data() ) + v.index() * stride2( v.data() ) ;
 620     }
 621     template < typename M >
 622     BOOST_UBLAS_INLINE
 623     typename M::array_type::pointer data( matrix_row<M> &v ) {
 624         return data( v.data() ) + v.index() * stride1( v.data() ) ;
 625     }
 626     template < typename M >
 627     BOOST_UBLAS_INLINE
 628     typename M::array_type::pointer data( matrix_column<M> &v ) {
 629         return data( v.data() ) + v.index() * stride2( v.data() ) ;
 630     }
 631
 632     template < typename M >
 633     BOOST_UBLAS_INLINE
 634     typename M::array_type::const_pointer data( const matrix_range<M> &m ) {
 635         return data( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 636     }
 637     template < typename M >
 638     BOOST_UBLAS_INLINE
 639     typename M::array_type::const_pointer data( const matrix_slice<M> &m ) {
 640         return data( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 641     }
 642     template < typename M >
 643     BOOST_UBLAS_INLINE
 644     typename M::array_type::const_pointer data_const( const matrix_range<M> &m ) {
 645         return data_const( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 646     }
 647     template < typename M >
 648     BOOST_UBLAS_INLINE
 649     typename M::array_type::const_pointer data_const( const matrix_slice<M> &m ) {
 650         return data_const( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 651     }
 652     template < typename M >
 653     BOOST_UBLAS_INLINE
 654     typename M::array_type::pointer data( matrix_range<M> &m ) {
 655         return data( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 656     }
 657     template < typename M >
 658     BOOST_UBLAS_INLINE
 659     typename M::array_type::pointer data( matrix_slice<M> &m ) {
 660         return data( m.data() ) + m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 661     }
 662
 663
 664     template < typename MV >
 665     BOOST_UBLAS_INLINE
 666     typename MV::array_type::const_pointer base( const MV &mv ) {
 667         return &mv.data().begin()[0] ;
 668     }
 669     template < typename MV >
 670     BOOST_UBLAS_INLINE
 671     typename MV::array_type::const_pointer base_const( const MV &mv ) {
 672         return &mv.data().begin()[0] ;
 673     }
 674     template < typename MV >
 675     BOOST_UBLAS_INLINE
 676     typename MV::array_type::pointer base( MV &mv ) {
 677         return &mv.data().begin()[0] ;
 678     }
 679
 680     template < typename V >
 681     BOOST_UBLAS_INLINE
 682     typename V::array_type::const_pointer base( const vector_reference<V> &v ) {
 683         return base( v.expression () ) ;
 684     }
 685     template < typename V >
 686     BOOST_UBLAS_INLINE
 687     typename V::array_type::const_pointer base_const( const vector_reference<V> &v ) {
 688         return base_const( v.expression () ) ;
 689     }
 690     template < typename V >
 691     BOOST_UBLAS_INLINE
 692     typename V::array_type::pointer base( vector_reference<V> &v ) {
 693         return base( v.expression () ) ;
 694     }
 695
 696     template < typename T, std::size_t N >
 697     BOOST_UBLAS_INLINE
 698     typename c_vector<T, N>::array_type::const_pointer base( const c_vector<T, N> &v ) {
 699         return v.data() ;
 700     }
 701     template < typename T, std::size_t N >
 702     BOOST_UBLAS_INLINE
 703     typename c_vector<T, N>::array_type::const_pointer base_const( const c_vector<T, N> &v ) {
 704         return v.data() ;
 705     }
 706     template < typename T, std::size_t N >
 707     BOOST_UBLAS_INLINE
 708     typename c_vector<T, N>::pointer base( c_vector<T, N> &v ) {
 709         return v.data() ;
 710     }
 711
 712     template < typename V >
 713     BOOST_UBLAS_INLINE
 714     typename V::array_type::const_pointer base( const vector_range<V> &v ) {
 715         return base( v.data() ) ;
 716     }
 717     template < typename V >
 718     BOOST_UBLAS_INLINE
 719     typename V::array_type::const_pointer base( const vector_slice<V> &v ) {
 720         return base( v.data() ) ;
 721     }
 722     template < typename V >
 723     BOOST_UBLAS_INLINE
 724     typename V::array_type::const_pointer base_const( const vector_range<V> &v ) {
 725         return base_const( v.data() ) ;
 726     }
 727     template < typename V >
 728     BOOST_UBLAS_INLINE
 729     typename V::array_type::const_pointer base_const( const vector_slice<V> &v ) {
 730         return base_const( v.data() ) ;
 731     }
 732     template < typename V >
 733     BOOST_UBLAS_INLINE
 734     typename V::array_type::pointer base( vector_range<V> &v ) {
 735         return base( v.data() ) ;
 736     }
 737     template < typename V >
 738     BOOST_UBLAS_INLINE
 739     typename V::array_type::pointer base( vector_slice<V> &v ) {
 740         return base( v.data() ) ;
 741     }
 742
 743     template < typename M >
 744     BOOST_UBLAS_INLINE
 745     typename M::array_type::const_pointer base( const matrix_reference<M> &m ) {
 746         return base( m.expression () ) ;
 747     }
 748     template < typename M >
 749     BOOST_UBLAS_INLINE
 750     typename M::array_type::const_pointer base_const( const matrix_reference<M> &m ) {
 751         return base_const( m.expression () ) ;
 752     }
 753     template < typename M >
 754     BOOST_UBLAS_INLINE
 755     typename M::array_type::pointer base( matrix_reference<M> &m ) {
 756         return base( m.expression () ) ;
 757     }
 758
 759     template < typename T, std::size_t M, std::size_t N >
 760     BOOST_UBLAS_INLINE
 761     typename c_matrix<T, M, N>::array_type::const_pointer base( const c_matrix<T, M, N> &m ) {
 762         return m.data() ;
 763     }
 764     template < typename T, std::size_t M, std::size_t N >
 765     BOOST_UBLAS_INLINE
 766     typename c_matrix<T, M, N>::array_type::const_pointer base_const( const c_matrix<T, M, N> &m ) {
 767         return m.data() ;
 768     }
 769     template < typename T, std::size_t M, std::size_t N >
 770     BOOST_UBLAS_INLINE
 771     typename c_matrix<T, M, N>::pointer base( c_matrix<T, M, N> &m ) {
 772         return m.data() ;
 773     }
 774
 775     template < typename M >
 776     BOOST_UBLAS_INLINE
 777     typename M::array_type::const_pointer base( const matrix_row<M> &v ) {
 778         return base( v.data() ) ;
 779     }
 780     template < typename M >
 781     BOOST_UBLAS_INLINE
 782     typename M::array_type::const_pointer base( const matrix_column<M> &v ) {
 783         return base( v.data() ) ;
 784     }
 785     template < typename M >
 786     BOOST_UBLAS_INLINE
 787     typename M::array_type::const_pointer base_const( const matrix_row<M> &v ) {
 788         return base_const( v.data() ) ;
 789     }
 790     template < typename M >
 791     BOOST_UBLAS_INLINE
 792     typename M::array_type::const_pointer base_const( const matrix_column<M> &v ) {
 793         return base_const( v.data() ) ;
 794     }
 795     template < typename M >
 796     BOOST_UBLAS_INLINE
 797     typename M::array_type::pointer base( matrix_row<M> &v ) {
 798         return base( v.data() ) ;
 799     }
 800     template < typename M >
 801     BOOST_UBLAS_INLINE
 802     typename M::array_type::pointer base( matrix_column<M> &v ) {
 803         return base( v.data() ) ;
 804     }
 805
 806     template < typename M >
 807     BOOST_UBLAS_INLINE
 808     typename M::array_type::const_pointer base( const matrix_range<M> &m ) {
 809         return base( m.data() ) ;
 810     }
 811     template < typename M >
 812     BOOST_UBLAS_INLINE
 813     typename M::array_type::const_pointer base( const matrix_slice<M> &m ) {
 814         return base( m.data() ) ;
 815     }
 816     template < typename M >
 817     BOOST_UBLAS_INLINE
 818     typename M::array_type::const_pointer base_const( const matrix_range<M> &m ) {
 819         return base_const( m.data() ) ;
 820     }
 821     template < typename M >
 822     BOOST_UBLAS_INLINE
 823     typename M::array_type::const_pointer base_const( const matrix_slice<M> &m ) {
 824         return base_const( m.data() ) ;
 825     }
 826     template < typename M >
 827     BOOST_UBLAS_INLINE
 828     typename M::array_type::pointer base( matrix_range<M> &m ) {
 829         return base( m.data() ) ;
 830     }
 831     template < typename M >
 832     BOOST_UBLAS_INLINE
 833     typename M::array_type::pointer base( matrix_slice<M> &m ) {
 834         return base( m.data() ) ;
 835     }
 836
 837     template < typename MV >
 838     BOOST_UBLAS_INLINE
 839     typename MV::size_type start( const MV &mv ) {
 840         return 0 ;
 841     }
 842
 843     template < typename V >
 844     BOOST_UBLAS_INLINE
 845     typename V::size_type start( const vector_range<V> &v ) {
 846         return v.start() * stride (v.data() ) ;
 847     }
 848     template < typename V >
 849     BOOST_UBLAS_INLINE
 850     typename V::size_type start( const vector_slice<V> &v ) {
 851         return v.start() * stride (v.data() ) ;
 852     }
 853
 854     template < typename M >
 855     BOOST_UBLAS_INLINE
 856     typename M::size_type start( const matrix_row<M> &v ) {
 857         return v.index() * stride1( v.data() ) ;
 858     }
 859     template < typename M >
 860     BOOST_UBLAS_INLINE
 861     typename M::size_type start( const matrix_column<M> &v ) {
 862         return v.index() * stride2( v.data() ) ;
 863     }
 864
 865     template < typename M >
 866     BOOST_UBLAS_INLINE
 867     typename M::size_type start( const matrix_range<M> &m ) {
 868         return m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 869     }
 870     template < typename M >
 871     BOOST_UBLAS_INLINE
 872     typename M::size_type start( const matrix_slice<M> &m ) {
 873         return m.start1() * stride1( m.data () ) + m.start2() * stride2( m.data () ) ;
 874     }
 875
 876 }}}}
 877
 878 #endif