merged

dlib/array2d/array2d_kernel.h

@@ -161,7 +161,7 @@ namespace dlib
         }
 
 #ifdef DLIB_HAS_RVALUE_REFERENCES
-        array2d(array2d&& item)
+        array2d(array2d&& item) : array2d()
         {
             swap(item);
         }

dlib/dnn/core.h

@@ -51,25 +51,25 @@ namespace dlib
     template <typename T, size_t N>
     class sstack
     {
-        public:
-            static_assert(N > 0, "You can't create an empty sstack.");
-            typedef T value_type;
-            const static size_t num_elements = N;
+    public:
+        static_assert(N > 0, "You can't create an empty sstack.");
+        typedef T value_type;
+        const static size_t num_elements = N;
 
-            sstack() {}
-            sstack(const T& item_) : item(item_), data(item_) {}
+        sstack() {}
+        sstack(const T& item_) : item(item_), data(item_) {}
 
-            const T& top() const { return item; }
-            T& top() { return item; }
+        const T& top() const { return item; }
+        T& top() { return item; }
 
-            size_t size() const { return N; }
+        size_t size() const { return N; }
 
-            const sstack<T,N-1>& pop() const { return data; }
-            sstack<T,N-1>& pop() { return data; }
+        const sstack<T,N-1>& pop() const { return data; }
+        sstack<T,N-1>& pop() { return data; }
 
-        private:
-            T item;
-            sstack<T,N-1> data;
+    private:
+        T item;
+        sstack<T,N-1> data;
     };
 
     template <typename T>

dlib/dnn/core_abstract.h

@@ -52,72 +52,72 @@ namespace dlib
                 entirely allocated on the stack.
         !*/
 
-        public:
-            typedef T value_type;
-            const static size_t num_elements = N;
-
-            sstack(
-            );
-            /*!
-                ensures
-                    - #size() == N
-                    - All elements of this stack are default constructed.
-            !*/
-
-            sstack(
-                const T& item
-            );
-            /*!
-                ensures
-                    - #size() == N
-                    - Initializes all N elements in this stack with the given item.
-                      E.g. top()==item, pop().top()==item, pop().pop().top()==item, etc.
-            !*/
-
-            const T& top(
-            ) const;
-            /*!
-                ensures
-                    - returns the top element of the stack.
-            !*/
-
-            T& top(
-            );
-            /*!
-                ensures
-                    - returns the top element of the stack.  
-            !*/
-
-
-            size_t size(
-            ) const;
-            /*!
-                ensures
-                    - returns the number of elements in this stack.  In particular, the
-                      number returned is always N.
-            !*/
-
-            const sstack<T,N-1>& pop(
-            ) const;
-            /*!
-                requires
-                    - size() > 1
-                ensures
-                    - returns a reference to the sub-stack S such that:
-                        - S.size() == size()-1.
-                        - S.top() is the next element in the stack.
-            !*/
-
-            sstack<T,N-1>& pop(
-            ); 
-            /*!
-                requires
-                    - size() > 1
-                ensures
-                    - returns a reference to the sub-stack S such that:
-                        - S.size() == size()-1.
-                        - S.top() is the next element in the stack.
-            !*/
+    public:
+        typedef T value_type;
+        const static size_t num_elements = N;
+
+        sstack(
+        );
+        /*!
+            ensures
+                - #size() == N
+                - All elements of this stack are default constructed.
+        !*/
+
+        sstack(
+            const T& item
+        );
+        /*!
+            ensures
+                - #size() == N
+                - Initializes all N elements in this stack with the given item.  E.g.
+                  top()==item, pop().top()==item, pop().pop().top()==item, etc.
+        !*/
+
+        const T& top(
+        ) const;
+        /*!
+            ensures
+                - returns the top element of the stack.
+        !*/
+
+        T& top(
+        );
+        /*!
+            ensures
+                - returns the top element of the stack.  
+        !*/
+
+
+        size_t size(
+        ) const;
+        /*!
+            ensures
+                - returns the number of elements in this stack.  In particular, the number
+                  returned is always N.
+        !*/
+
+        const sstack<T,N-1>& pop(
+        ) const;
+        /*!
+            requires
+                - size() > 1
+            ensures
+                - returns a reference to the sub-stack S such that:
+                    - S.size() == size()-1.
+                    - S.top() is the next element in the stack.
+        !*/
+
+        sstack<T,N-1>& pop(
+        ); 
+        /*!
+            requires
+                - size() > 1
+            ensures
+                - returns a reference to the sub-stack S such that:
+                    - S.size() == size()-1.
+                    - S.top() is the next element in the stack.
+        !*/
     };
 
 // ----------------------------------------------------------------------------------------

dlib/dnn/input_abstract.h

@@ -44,10 +44,10 @@ namespace dlib
             ensures
                 - Constructs this object from item.  This form of constructor is optional
                   but it allows you to provide a conversion from one input layer type to
-                  another.  For example, the following code is valid only if my_input2 can
-                  be constructed from my_input1:
-                    relu<fc<relu<fc<my_input1>>>> my_dnn1;
-                    relu<fc<relu<fc<my_input2>>>> my_dnn2(my_dnn1);
+                  another.  For example, the following code is valid only if my_input_layer2 can
+                  be constructed from my_input_layer1:
+                    relu<fc<relu<fc<my_input_layer1>>>> my_dnn1;
+                    relu<fc<relu<fc<my_input_layer2>>>> my_dnn2(my_dnn1);
                   This kind of pattern is useful if you want to use one type of input layer
                   during training but a different type of layer during testing since it
                   allows you to easily convert between related deep neural network types.