Only in Boost/boost: .DS_Store
diff -dur boost_1_53_0/boost/concept_check.hpp Boost/boost/concept_check.hpp
old
|
new
|
|
880 | 880 | typename BackInsertionSequence::const_reference |
881 | 881 | r = cc.back(); |
882 | 882 | ignore_unused_variable_warning(r); |
883 | | }; |
| 883 | } |
884 | 884 | S c; |
885 | 885 | typename S::value_type t; |
886 | 886 | }; |
diff -dur boost_1_53_0/boost/function/function_base.hpp Boost/boost/function/function_base.hpp
old
|
new
|
|
435 | 435 | out_buffer.type.const_qualified = false; |
436 | 436 | out_buffer.type.volatile_qualified = false; |
437 | 437 | return; |
| 438 | |
| 439 | case clone_functor_tag: |
| 440 | case move_functor_tag: |
| 441 | case destroy_functor_tag: |
| 442 | case check_functor_type_tag: |
438 | 443 | |
439 | | default: |
440 | 444 | manager(in_buffer, out_buffer, op, tag_type()); |
441 | 445 | return; |
442 | 446 | } |
… |
… |
|
539 | 543 | out_buffer.type.volatile_qualified = false; |
540 | 544 | return; |
541 | 545 | |
542 | | default: |
| 546 | case clone_functor_tag: |
| 547 | case move_functor_tag: |
| 548 | case destroy_functor_tag: |
| 549 | case check_functor_type_tag: |
543 | 550 | manager(in_buffer, out_buffer, op, tag_type()); |
544 | 551 | return; |
545 | 552 | } |
diff -dur boost_1_53_0/boost/lexical_cast.hpp Boost/boost/lexical_cast.hpp
old
|
new
|
|
2225 | 2225 | > interpreter_type; |
2226 | 2226 | |
2227 | 2227 | // Target type must be default constructible |
2228 | | Target result; |
| 2228 | Target result = Target(); |
2229 | 2229 | |
2230 | 2230 | BOOST_DEDUCED_TYPENAME stream_trait::char_type buf[stream_trait::len_t::value + 1]; |
2231 | 2231 | stream_trait::len_t::check_coverage(); |
Only in Boost/boost/numeric: .DS_Store
Only in Boost/boost/numeric/ublas: .DS_Store
diff -dur boost_1_53_0/boost/numeric/ublas/detail/iterator.hpp Boost/boost/numeric/ublas/detail/iterator.hpp
old
|
new
|
|
22 | 22 | /** \brief Base class of all proxy classes that contain |
23 | 23 | * a (redirectable) reference to an immutable object. |
24 | 24 | * |
25 | | * \param C the type of the container referred to |
| 25 | * \tparam C the type of the container referred to |
26 | 26 | */ |
27 | 27 | template<class C> |
28 | 28 | class container_const_reference: |
… |
… |
|
61 | 61 | /** \brief Base class of all proxy classes that contain |
62 | 62 | * a (redirectable) reference to a mutable object. |
63 | 63 | * |
64 | | * \param C the type of the container referred to |
| 64 | * \tparam C the type of the container referred to |
65 | 65 | */ |
66 | 66 | template<class C> |
67 | 67 | class container_reference: |
… |
… |
|
99 | 99 | |
100 | 100 | /** \brief Base class of all forward iterators. |
101 | 101 | * |
102 | | * \param IC the iterator category |
103 | | * \param I the derived iterator type |
104 | | * \param T the value type |
| 102 | * \tparam IC the iterator category |
| 103 | * \tparam I the derived iterator type |
| 104 | * \tparam T the value type |
105 | 105 | * |
106 | 106 | * The forward iterator can only proceed in one direction |
107 | 107 | * via the post increment operator. |
… |
… |
|
137 | 137 | |
138 | 138 | /** \brief Base class of all bidirectional iterators. |
139 | 139 | * |
140 | | * \param IC the iterator category |
141 | | * \param I the derived iterator type |
142 | | * \param T the value type |
| 140 | * \tparam IC the iterator category |
| 141 | * \tparam I the derived iterator type |
| 142 | * \tparam T the value type |
143 | 143 | * |
144 | 144 | * The bidirectional iterator can proceed in both directions |
145 | 145 | * via the post increment and post decrement operator. |
… |
… |
|
188 | 188 | |
189 | 189 | /** \brief Base class of all random access iterators. |
190 | 190 | * |
191 | | * \param IC the iterator category |
192 | | * \param I the derived iterator type |
193 | | * \param T the value type |
194 | | * \param D the difference type, default: std::ptrdiff_t |
| 191 | * \tparam IC the iterator category |
| 192 | * \tparam I the derived iterator type |
| 193 | * \tparam T the value type |
| 194 | * \tparam D the difference type, default: std::ptrdiff_t |
195 | 195 | * |
196 | 196 | * The random access iterator can proceed in both directions |
197 | 197 | * via the post increment/decrement operator or in larger steps |
… |
… |
|
293 | 293 | |
294 | 294 | /** \brief Base class of all reverse iterators. (non-MSVC version) |
295 | 295 | * |
296 | | * \param I the derived iterator type |
297 | | * \param T the value type |
298 | | * \param R the reference type |
| 296 | * \tparam I the derived iterator type |
299 | 297 | * |
300 | 298 | * The reverse iterator implements a bidirectional iterator |
301 | 299 | * reversing the elements of the underlying iterator. It |
… |
… |
|
388 | 386 | |
389 | 387 | /** \brief 1st base class of all matrix reverse iterators. (non-MSVC version) |
390 | 388 | * |
391 | | * \param I the derived iterator type |
| 389 | * \tparam I the derived iterator type |
392 | 390 | * |
393 | 391 | * The reverse iterator implements a bidirectional iterator |
394 | 392 | * reversing the elements of the underlying iterator. It |
… |
… |
|
508 | 506 | |
509 | 507 | /** \brief 2nd base class of all matrix reverse iterators. (non-MSVC version) |
510 | 508 | * |
511 | | * \param I the derived iterator type |
| 509 | * \tparam I the derived iterator type |
512 | 510 | * |
513 | 511 | * The reverse iterator implements a bidirectional iterator |
514 | 512 | * reversing the elements of the underlying iterator. It |
… |
… |
|
630 | 628 | |
631 | 629 | /** \brief A class implementing an indexed random access iterator. |
632 | 630 | * |
633 | | * \param C the (mutable) container type |
634 | | * \param IC the iterator category |
| 631 | * \tparam C the (mutable) container type |
| 632 | * \tparam IC the iterator category |
635 | 633 | * |
636 | 634 | * This class implements a random access iterator. The current |
637 | 635 | * position is stored as the unsigned integer it_ and the |
… |
… |
|
735 | 733 | |
736 | 734 | /** \brief A class implementing an indexed random access iterator. |
737 | 735 | * |
738 | | * \param C the (immutable) container type |
739 | | * \param IC the iterator category |
| 736 | * \tparam C the (immutable) container type |
| 737 | * \tparam IC the iterator category |
740 | 738 | * |
741 | 739 | * This class implements a random access iterator. The current |
742 | 740 | * position is stored as the unsigned integer \c it_ and the |
… |
… |
|
853 | 851 | /** \brief A class implementing an indexed random access iterator |
854 | 852 | * of a matrix. |
855 | 853 | * |
856 | | * \param C the (mutable) container type |
857 | | * \param IC the iterator category |
| 854 | * \tparam C the (mutable) container type |
| 855 | * \tparam IC the iterator category |
858 | 856 | * |
859 | 857 | * This class implements a random access iterator. The current |
860 | 858 | * position is stored as two unsigned integers \c it1_ and \c it2_ |
… |
… |
|
997 | 995 | /** \brief A class implementing an indexed random access iterator |
998 | 996 | * of a matrix. |
999 | 997 | * |
1000 | | * \param C the (immutable) container type |
1001 | | * \param IC the iterator category |
| 998 | * \tparam C the (immutable) container type |
| 999 | * \tparam IC the iterator category |
1002 | 1000 | * |
1003 | 1001 | * This class implements a random access iterator. The current |
1004 | 1002 | * position is stored as two unsigned integers \c it1_ and \c it2_ |
… |
… |
|
1146 | 1144 | /** \brief A class implementing an indexed random access iterator |
1147 | 1145 | * of a matrix. |
1148 | 1146 | * |
1149 | | * \param C the (mutable) container type |
1150 | | * \param IC the iterator category |
| 1147 | * \tparam C the (mutable) container type |
| 1148 | * \tparam IC the iterator category |
1151 | 1149 | * |
1152 | 1150 | * This class implements a random access iterator. The current |
1153 | 1151 | * position is stored as two unsigned integers \c it1_ and \c it2_ |
… |
… |
|
1285 | 1283 | /** \brief A class implementing an indexed random access iterator |
1286 | 1284 | * of a matrix. |
1287 | 1285 | * |
1288 | | * \param C the (immutable) container type |
1289 | | * \param IC the iterator category |
| 1286 | * \tparam C the (immutable) container type |
| 1287 | * \tparam IC the iterator category |
1290 | 1288 | * |
1291 | 1289 | * This class implements a random access iterator. The current |
1292 | 1290 | * position is stored as two unsigned integers \c it1_ and \c it2_ |
diff -dur boost_1_53_0/boost/numeric/ublas/lu.hpp Boost/boost/numeric/ublas/lu.hpp
old
|
new
|
|
23 | 23 | |
24 | 24 | namespace boost { namespace numeric { namespace ublas { |
25 | 25 | |
26 | | /** \brief |
| 26 | /** \brief ??? |
27 | 27 | * |
28 | | * \tparam T |
29 | | * \tparam A |
| 28 | * \tparam T ??? |
| 29 | * \tparam A ??? |
30 | 30 | */ |
31 | 31 | template<class T = std::size_t, class A = unbounded_array<T> > |
32 | 32 | class permutation_matrix: |
diff -dur boost_1_53_0/boost/numeric/ublas/matrix_proxy.hpp Boost/boost/numeric/ublas/matrix_proxy.hpp
old
|
new
|
|
22 | 22 | |
23 | 23 | namespace boost { namespace numeric { namespace ublas { |
24 | 24 | |
25 | | /** \brief |
| 25 | /** \brief ??? |
26 | 26 | */ |
27 | 27 | template<class M> |
28 | 28 | class matrix_row: |
… |
… |
|
4179 | 4179 | * falls outside that of the indices of the matrix, then the \c matrix_indirect is not a well formed |
4180 | 4180 | * \i Matrix \i Expression and access to an element outside of indices of the matrix is \b undefined. |
4181 | 4181 | * |
4182 | | * \tparam V the type of the referenced matrix, for example \c matrix<double>) |
4183 | 4182 | * \tparam IA the type of index matrix. Default is \c ublas::indirect_array<> |
4184 | 4183 | */ |
4185 | 4184 | template<class M, class IA> |
diff -dur boost_1_53_0/boost/numeric/ublas/operation.hpp Boost/boost/numeric/ublas/operation.hpp
old
|
new
|
|
234 | 234 | \internal |
235 | 235 | |
236 | 236 | template parameters: |
237 | | \param V type of the result vector \c v |
238 | | \param E1 type of a matrix expression \c A |
239 | | \param E2 type of a vector expression \c x |
| 237 | \tparam V type of the result vector \c v |
| 238 | \tparam E1 type of a matrix expression \c A |
| 239 | \tparam E2 type of a vector expression \c x |
240 | 240 | */ |
241 | 241 | template<class V, class E1, class E2> |
242 | 242 | BOOST_UBLAS_INLINE |
… |
… |
|
456 | 456 | \internal |
457 | 457 | |
458 | 458 | template parameters: |
459 | | \param V type of the result vector \c v |
460 | | \param E1 type of a vector expression \c x |
461 | | \param E2 type of a matrix expression \c A |
| 459 | \tparam V type of the result vector \c v |
| 460 | \tparam E1 type of a vector expression \c x |
| 461 | \tparam E2 type of a matrix expression \c A |
462 | 462 | */ |
463 | 463 | template<class V, class E1, class E2> |
464 | 464 | BOOST_UBLAS_INLINE |
… |
… |
|
701 | 701 | \internal |
702 | 702 | |
703 | 703 | template parameters: |
704 | | \param M type of the result matrix \c M |
705 | | \param E1 type of a matrix expression \c A |
706 | | \param E2 type of a matrix expression \c X |
| 704 | \tparam M type of the result matrix \c M |
| 705 | \tparam E1 type of a matrix expression \c A |
| 706 | \tparam E2 type of a matrix expression \c X |
707 | 707 | */ |
708 | 708 | template<class M, class E1, class E2> |
709 | 709 | BOOST_UBLAS_INLINE |
… |
… |
|
817 | 817 | \internal |
818 | 818 | |
819 | 819 | template parameters: |
820 | | \param M type of the result matrix \c M |
821 | | \param E1 type of a matrix expression \c A |
822 | | \param E2 type of a matrix expression \c X |
| 820 | \tparam M type of the result matrix \c M |
| 821 | \tparam E1 type of a matrix expression \c A |
| 822 | \tparam E2 type of a matrix expression \c X |
823 | 823 | */ |
824 | 824 | template<class M, class E1, class E2> |
825 | 825 | BOOST_UBLAS_INLINE |
diff -dur boost_1_53_0/boost/numeric/ublas/triangular.hpp Boost/boost/numeric/ublas/triangular.hpp
old
|
new
|
|
2162 | 2162 | singular ().raise (); |
2163 | 2163 | #endif |
2164 | 2164 | value_type t = e2 () (n); |
2165 | | for (difference_type m = n + 1; m < e1 ().size2(); ++ m) { |
| 2165 | for (difference_type m = n + 1; m < static_cast<difference_type>(e1 ().size2()); ++ m) { |
2166 | 2166 | t -= e1 () (n, m) * e2 () (m); |
2167 | 2167 | } |
2168 | 2168 | e2() (n) = t / e1 () (n, n); |
diff -dur boost_1_53_0/boost/numeric/ublas/vector.hpp Boost/boost/numeric/ublas/vector.hpp
old
|
new
|
|
85 | 85 | BOOST_UBLAS_INLINE |
86 | 86 | vector (size_type size, const array_type &data): |
87 | 87 | vector_container<self_type> (), |
88 | | data_ (data) {} |
| 88 | data_ (data) {(void)size;} |
89 | 89 | |
90 | 90 | /// \brief Constructor of a vector by copying from another container |
91 | 91 | /// This type has the generic name \c array_typ within the vector definition. |
… |
… |
|
354 | 354 | /// \brief Assign the sum of the vector and a vector_expression to the vector |
355 | 355 | /// Assign the sum of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. |
356 | 356 | /// No temporary is created. Computations are done and stored directly into the resulting vector. |
357 | | /// \tparam AE is the type of the vector_expression |
358 | | /// \param ae is a const reference to the vector_expression |
359 | 357 | /// \return a reference to the resulting vector |
360 | 358 | template<class C> // Container assignment without temporary |
361 | 359 | BOOST_UBLAS_INLINE |
… |
… |
|
392 | 390 | /// \brief Assign the difference of the vector and a vector_expression to the vector |
393 | 391 | /// Assign the difference of the vector and a vector_expression to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. |
394 | 392 | /// No temporary is created. Computations are done and stored directly into the resulting vector. |
395 | | /// \tparam AE is the type of the vector_expression |
396 | | /// \param ae is a const reference to the vector_expression |
397 | 393 | /// \return a reference to the resulting vector |
398 | 394 | template<class C> // Container assignment without temporary |
399 | 395 | BOOST_UBLAS_INLINE |
… |
… |
|
418 | 414 | /// \brief Assign the product of the vector and a scalar to the vector |
419 | 415 | /// Assign the product of the vector and a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. |
420 | 416 | /// No temporary is created. Computations are done and stored directly into the resulting vector. |
421 | | /// \tparam AE is the type of the vector_expression |
422 | 417 | /// \param at is a const reference to the scalar |
423 | 418 | /// \return a reference to the resulting vector |
424 | 419 | template<class AT> |
… |
… |
|
431 | 426 | /// \brief Assign the division of the vector by a scalar to the vector |
432 | 427 | /// Assign the division of the vector by a scalar to the vector. This is lazy-compiled and will be optimized out by the compiler on any type of expression. |
433 | 428 | /// No temporary is created. Computations are done and stored directly into the resulting vector. |
434 | | /// \tparam AE is the type of the vector_expression |
435 | 429 | /// \param at is a const reference to the scalar |
436 | 430 | /// \return a reference to the resulting vector |
437 | 431 | template<class AT> |
… |
… |
|
782 | 776 | |
783 | 777 | /// Serialize a vector into and archive as defined in Boost |
784 | 778 | /// \param ar Archive object. Can be a flat file, an XML file or any other stream |
785 | | /// \param file_version Optional file version (not yet used) |
786 | 779 | template<class Archive> |
787 | 780 | void serialize(Archive & ar, const unsigned int /* file_version */){ |
788 | 781 | ar & serialization::make_nvp("data",data_); |
… |
… |
|
923 | 916 | // Element support |
924 | 917 | BOOST_UBLAS_INLINE |
925 | 918 | const_pointer find_element (size_type i) const { |
| 919 | (void)i; |
926 | 920 | return & zero_; |
927 | 921 | } |
928 | 922 | |
… |
… |
|
1632 | 1626 | // Resizing |
1633 | 1627 | BOOST_UBLAS_INLINE |
1634 | 1628 | void resize (size_type size, bool preserve = true) { |
| 1629 | (void)preserve; |
1635 | 1630 | if (size > N) |
1636 | 1631 | bad_size ().raise (); |
1637 | 1632 | size_ = size; |
diff -dur boost_1_53_0/boost/range/iterator_range_core.hpp Boost/boost/range/iterator_range_core.hpp
old
|
new
|
|
631 | 631 | Construct a new sequence of the specified type from the elements |
632 | 632 | in the given range |
633 | 633 | |
634 | | \param Range An input range |
| 634 | \tparam Range An input range |
635 | 635 | \return New sequence |
636 | 636 | */ |
637 | | template< typename SeqT, typename Range > |
| 637 | template< typename SeqT, class Range > |
638 | 638 | inline SeqT copy_range( const Range& r ) |
639 | 639 | { |
640 | 640 | return SeqT( boost::begin( r ), boost::end( r ) ); |
diff -dur boost_1_53_0/boost/serialization/collection_size_type.hpp Boost/boost/serialization/collection_size_type.hpp
old
|
new
|
|
22 | 22 | typedef std::size_t base_type; |
23 | 23 | base_type t; |
24 | 24 | public: |
25 | | collection_size_type(): t(0) {}; |
| 25 | collection_size_type(): t(0) {} |
26 | 26 | explicit collection_size_type(const std::size_t & t_) : |
27 | 27 | t(t_) |
28 | 28 | {} |
diff -dur boost_1_53_0/boost/serialization/strong_typedef.hpp Boost/boost/serialization/strong_typedef.hpp
old
|
new
|
|
33 | 33 | > > \ |
34 | 34 | { \ |
35 | 35 | T t; \ |
36 | | explicit D(const T t_) : t(t_) {}; \ |
37 | | D(): t() {}; \ |
| 36 | explicit D(const T t_) : t(t_) {} \ |
| 37 | D(): t() {} \ |
38 | 38 | D(const D & t_) : t(t_.t){} \ |
39 | 39 | D & operator=(const D & rhs) { t = rhs.t; return *this;} \ |
40 | 40 | D & operator=(const T & rhs) { t = rhs; return *this;} \ |
… |
… |
|
51 | 51 | > > \ |
52 | 52 | { \ |
53 | 53 | T t; \ |
54 | | explicit D(const T t_) : t(t_) {}; \ |
55 | | D() : t(){}; \ |
| 54 | explicit D(const T t_) : t(t_) {} \ |
| 55 | D() : t(){} \ |
56 | 56 | D(const D & t_) : t(t_.t){} \ |
57 | 57 | D & operator=(const D & rhs) { t = rhs.t; return *this;} \ |
58 | 58 | D & operator=(const T & rhs) { t = rhs; return *this;} \ |
diff -dur boost_1_53_0/boost/strong_typedef.hpp Boost/boost/strong_typedef.hpp
old
|
new
|
|
33 | 33 | > > \ |
34 | 34 | { \ |
35 | 35 | T t; \ |
36 | | explicit D(const T t_) : t(t_) {}; \ |
37 | | D(){}; \ |
| 36 | explicit D(const T t_) : t(t_) {} \ |
| 37 | D(){} \ |
38 | 38 | D(const D & t_) : t(t_.t){} \ |
39 | 39 | D & operator=(const D & rhs) { t = rhs.t; return *this;} \ |
40 | 40 | D & operator=(const T & rhs) { t = rhs; return *this;} \ |
… |
… |
|
51 | 51 | > > \ |
52 | 52 | { \ |
53 | 53 | T t; \ |
54 | | explicit D(const T t_) : t(t_) {}; \ |
55 | | D(){}; \ |
| 54 | explicit D(const T t_) : t(t_) {} \ |
| 55 | D(){} \ |
56 | 56 | D(const D & t_) : t(t_.t){} \ |
57 | 57 | D & operator=(const D & rhs) { t = rhs.t; return *this;} \ |
58 | 58 | D & operator=(const T & rhs) { t = rhs; return *this;} \ |