@@ -29,3 +29,6 @@ Defined in ``xtensor/xsort.hpp``
 
 .. doxygenfunction:: xt::argmax(const xexpression<E>&, std::size_t)
    :project: xtensor
+
+.. doxygenfunction:: xt::unique(const xexpression<E>&)
+   :project: xtensor
@@ -34,6 +34,9 @@ Defined in ``xtensor/xstrided_view.hpp``
 .. doxygenfunction:: xt::flatten
    :project: xtensor
 
+.. doxygenfunction:: xt::trim_zeros
+   :project: xtensor
+
 .. doxygenfunction:: xt::squeeze(E&&)
    :project: xtensor
 
@@ -56,4 +59,4 @@ Defined in ``xtensor/xstrided_view.hpp``
    :project: xtensor
 
 .. doxygenfunction:: xt::atleast_3d
-   :project: xtensor
+   :project: xtensor
@@ -29,3 +29,6 @@ Defined in ``xtensor/xslice.hpp``
 
 .. doxygenfunction:: xt::newaxis
    :project: xtensor
+
+.. doxygenfunction:: xt::ellipsis
+   :project: xtensor
@@ -132,6 +132,7 @@ or temporary variables are created.
 | | ``a[:, np.newaxis]``                              | | ``xt::view(a, xt::all(), xt::newaxis())``         |
 | | ``a[:5, 1:]``                                     | | ``xt::view(a, xt::range(_, 5), xt::range(1, _))`` |
 | | ``a[5:1:-1, :]``                                  | | ``xt::view(a, xt::range(5, 1, -1), xt::all())``   |
+| | ``a[..., 3]``                                     | | ``xt::dynamic_view(a, {xt::ellipsis, 3})``        |
 +-----------------------------------------------------+-----------------------------------------------------+
 | ``np.broadcast(a, [4, 5, 7])``                      | ``xt::broadcast(a, {4, 5, 7})``                     |
 +-----------------------------------------------------+-----------------------------------------------------+
@@ -283,6 +284,8 @@ Minimum, Maximum, Sorting
 +--------------------------------------------+-----------------------------------------------+
 | ``np.sort(a, axis=1)``                     | ``xt::sort(a, axis=1)``                       |
 +--------------------------------------------+-----------------------------------------------+
+| ``np.unique(a)``                           | ``xt::unique(a)``                             |
++--------------------------------------------+-----------------------------------------------+
 
 Complex numbers
 ---------------
 
@@ -92,7 +92,7 @@ namespace xt
 
     /**
      * Create a xcontainer (xarray, xtensor or xtensorf) with uninitialized values of
-     * the same shape, value type and layout as @emph e.
+     * the same shape, value type and layout as the input xexpression *e*.
      *
      * @param e the xexpression from which to extract shape, value type and layout.
      */
@@ -104,10 +104,11 @@ namespace xt
     }
 
     /**
-     * Create a xcontainer (xarray, xtensor or xtensorf), filled with @emph fill_value and of
-     * the same shape, value type and layout as @emph e.
+     * Create a xcontainer (xarray, xtensor or xtensorf), filled with *fill_value* and of
+     * the same shape, value type and layout as the input xexpression *e*.
      *
      * @param e the xexpression from which to extract shape, value type and layout.
+     * @param fill_value the value used to set each element of the returned xcontainer.
      */
     template <class E>
     inline typename E::temporary_type full_like(const xexpression<E>& e, typename E::value_type fill_value)
@@ -117,9 +118,11 @@ namespace xt
     }
 
     /**
-     * Create a xcontainer (xarray, xtensor or xtensorf), filled with @emph zeros and of
-     * the same shape, value type and layout as @emph e. Note: contrary to zeros(shape), this function
-     * returns a non-lazy, evaluated container! Use ``xt::zeros<double>(e.shape());` for a lazy version.
+     * Create a xcontainer (xarray, xtensor or xtensorf), filled with zeros and of
+     * the same shape, value type and layout as the input xexpression *e*.
+     *
+     * Note: contrary to zeros(shape), this function returns a non-lazy, allocated container! 
+     * Use ``xt::zeros<double>(e.shape());` for a lazy version.
      *
      * @param e the xexpression from which to extract shape, value type and layout.
      */
@@ -130,9 +133,11 @@ namespace xt
     }
 
     /**
-     * Create a xcontainer (xarray, xtensor or xtensorf), filled with @emph ones and of
-     * the same shape, value type and layout as @emph e. Note: contrary to ones(shape), this function
-     * returns a non-lazy, evaluated container! Use ``xt::ones<double>(e.shape());` for a lazy version.
+     * Create a xcontainer (xarray, xtensor or xtensorf), filled with ones and of
+     * the same shape, value type and layout as the input xexpression *e*.
+     *
+     * Note: contrary to ones(shape), this function returns a non-lazy, evaluated container!
+     * Use ``xt::ones<double>(e.shape());`` for a lazy version.
      *
      * @param e the xexpression from which to extract shape, value type and layout.
      */
 
@@ -152,16 +152,57 @@ namespace xt
     /**
      * Returns a slice representing a full dimension,
      * to be used as an argument of view function.
-     * @sa view
+     * @sa view, dynamic_view
      */
     inline auto all() noexcept
     {
         return xall_tag();
     }
 
+    template <class T>
+    class xellipsis : public xslice<xellipsis<T>>
+    {
+    public:
+
+        using size_type = T;
+
+        xellipsis() = default;
+
+        size_type operator()(size_type i) const noexcept;
+
+        size_type size() const noexcept;
+        size_type step_size() const noexcept;
+
+    };
+
+    struct xellipsis_tag
+    {
+    };
+
+    /**
+     * Returns a slice representing all remaining dimensions,
+     * and selecting all in these dimensions. Ellipsis will expand
+     * to a series of `all()` slices, until the number of slices is
+     * equal to the number of dimensions of the source array.
+     *
+     * Note: ellipsis can only be used in dynamic_view!
+     *
+     * \code{.cpp}
+     * xarray<double> a = xarray<double>::from_shape({5, 5, 1, 1, 5});
+     * auto v = xt::dynamic_view(a, {2, xt::ellipsis(), 2});
+     * // equivalent to using {2, xt::all(), xt::all(), xt::all(), 2};
+     * \endcode
+     *
+     * @sa dynamic_view
+     */
+    inline auto ellipsis() noexcept
+    {
+        return xellipsis_tag();
+    }
+
     /************************
-    * xnewaxis declaration *
-    ************************/
+     * xnewaxis declaration *
+     ************************/
 
     template <class T>
     class xnewaxis : public xslice<xnewaxis<T>>
@@ -183,10 +224,10 @@ namespace xt
     };
 
     /**
-    * Returns a slice representing a new axis of length one,
-    * to be used as an argument of view function.
-    * @sa view
-    */
+     * Returns a slice representing a new axis of length one,
+     * to be used as an argument of view function.
+     * @sa view, dynamic_view
+     */
     inline auto newaxis() noexcept
     {
         return xnewaxis_tag();
@@ -285,12 +326,37 @@ namespace xt
         C m_step;
     };
 
+    /**
+     * Select a range from min_val to max_val.
+     * You can use the shorthand `_` syntax to select from the start or until the end.
+     *
+     * \code{.cpp}
+     * using namespace xt::placeholders;  // to enable _ syntax
+     *
+     * range(3, _)  // select from index 3 to the end
+     * range(_, 5)  // select from index o to 5
+     * range(_, _)  // equivalent to `all()`
+     * \endcode
+     *
+     * @sa view, dynamic_view
+     */
     template <class A, class B>
     inline auto range(A min_val, B max_val)
     {
         return xrange_adaptor<A, B, placeholders::xtuph>(min_val, max_val, placeholders::xtuph());
     }
 
+    /**
+     * Select a range from min_val to max_val with step
+     * You can use the shorthand `_` syntax to select from the start or until the end.
+     *
+     * \code{.cpp}
+     * using namespace xt::placeholders;  // to enable _ syntax
+     * range(3, _, 5)  // select from index 3 to the end with stepsize 5
+     * \endcode
+     *
+     * @sa view, dynamic_view
+     */
     template <class A, class B, class C>
     inline auto range(A min_val, B max_val, C step)
     {
@@ -363,6 +429,12 @@ namespace xt
         return xall<typename E::size_type>(e.shape()[index]);
     }
 
+    template <class E>
+    inline auto get_slice_implementation(E& /*e*/, xellipsis_tag, std::size_t /*index*/)
+    {
+        return xellipsis<typename E::size_type>();
+    }
+
     template <class E>
     inline auto get_slice_implementation(E& /*e*/, xnewaxis_tag, std::size_t /*index*/)
     {
@@ -375,7 +447,6 @@ namespace xt
         return adaptor.get(e.shape()[index]);
     }
 
-
     /******************************
      * homogeneous get_slice_type *
      ******************************/
@@ -394,6 +465,12 @@ namespace xt
             using type = xall<typename E::size_type>;
         };
 
+        template <class E>
+        struct get_slice_type_impl<E, xellipsis_tag>
+        {
+            using type = xellipsis<typename E::size_type>;
+        };
+
         template <class E>
         struct get_slice_type_impl<E, xnewaxis_tag>
         {
@@ -510,9 +587,31 @@ namespace xt
         return 1;
     }
 
+    /****************************
+     * xellipsis implementation *
+     ****************************/
+
+    template <class T>
+    inline auto xellipsis<T>::operator()(size_type /*i*/) const noexcept -> size_type
+    {
+        return 0;
+    }
+
+    template <class T>
+    inline auto xellipsis<T>::size() const noexcept -> size_type
+    {
+        return 0;
+    }
+
+    template <class T>
+    inline auto xellipsis<T>::step_size() const noexcept -> size_type
+    {
+        return 1;
+    }
+
     /***************************
-    * xnewaxis implementation *
-    ***************************/
+     * xnewaxis implementation *
+     ***************************/
 
     template <class T>
     inline auto xnewaxis<T>::operator()(size_type) const noexcept -> size_type
 
@@ -257,7 +257,7 @@ namespace xt
     /**
      * Find position of minimal value in xexpression
      *
-     * @param a xexpression to compute argmin on
+     * @param e input xexpression
      * @param axis select axis (or none)
      *
      * @return returns xarray with positions of minimal value
@@ -281,7 +281,7 @@ namespace xt
     /**
      * Find position of maximal value in xexpression
      *
-     * @param a xexpression to compute argmin on
+     * @param e input xexpression
      * @param axis select axis (or none)
      *
      * @return returns xarray with positions of minimal value
@@ -293,6 +293,24 @@ namespace xt
         auto&& ed = eval(e.derived_cast());
         return detail::arg_func_impl(ed, axis, std::greater<value_type>());
     }
+
+    /**
+     * Find unique elements of a xexpression. This returns a flattened xtensor with
+     * sorted, unique elements from the original expression.
+     *
+     * @param e input xexpression (will be flattened)
+     */
+    template <class E>
+    auto unique(const xexpression<E>& e)
+    {
+        auto sorted = sort(e, xnone());
+        auto end = std::unique(sorted.begin(), sorted.end());
+        std::size_t sz = static_cast<std::size_t>(std::distance(sorted.begin(), end));
+        // TODO check if we can shrink the vector without reallocation
+        auto result = xtensor<typename E::value_type, 1>::from_shape({ sz });
+        std::copy(sorted.begin(), end, result.begin());
+        return result;
+    }
 }
 
 #endif