// Copyright (C) 2009 Davis E. King (davis@dlib.net) // License: Boost Software License See LICENSE.txt for the full license. #undef DLIB_SVm_SPARSE_VECTOR_ABSTRACT_ #ifdef DLIB_SVm_SPARSE_VECTOR_ABSTRACT_ #include <cmath> #include "../algs.h" #include "../serialize.h" namespace dlib { // ---------------------------------------------------------------------------------------- /*!A sparse_vectors In dlib, sparse vectors are represented using the container objects in the C++ STL. In particular, a sparse vector is any container that contains a sorted range of std::pair<key, scalar_value> objects where: - key is an unsigned integral type - scalar_value is float, double, or long double So examples of valid sparse vectors are: - std::map<unsigned long, double> - std::vector<std::pair<unsigned long, float> > where the vector is sorted. (you could make sure it was sorted by applying std::sort to it) This file defines a number of helper functions for doing normal vector arithmetic things with sparse vectors. !*/ // ---------------------------------------------------------------------------------------- namespace sparse_vector { template <typename T, typename U> typename T::value_type::second_type distance_squared ( const T& a, const U& b ); /*! requires - a is a sorted range of std::pair objects - b is a sorted range of std::pair objects ensures - returns the squared distance between the vectors a and b !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename U, typename V, typename W> typename T::value_type::second_type distance_squared ( const V& a_scale, const T& a, const W& b_scale, const U& b ); /*! requires - a is a sorted range of std::pair objects - b is a sorted range of std::pair objects ensures - returns the squared distance between the vectors a_scale*a and b_scale*b !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename U> typename T::value_type::second_type distance ( const T& a, const U& b ); /*! requires - a is a sorted range of std::pair objects - b is a sorted range of std::pair objects ensures - returns the distance between the vectors a and b. (i.e. std::sqrt(distance_squared(a,b))) !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename U, typename V, typename W> typename T::value_type::second_type distance ( const V& a_scale, const T& a, const W& b_scale, const U& b ); /*! requires - a is a sorted range of std::pair objects - b is a sorted range of std::pair objects ensures - returns the distance between the vectors a_scale*a and b_scale*b. (i.e. std::sqrt(distance_squared(a_scale,a,b_scale,b))) !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename EXP> void assign_dense_to_sparse ( T& dest, const matrix_exp<EXP>& src ); /*! requires - is_vector(src) == true - the key type in T is capable of holding integers or T is a dlib::matrix capable of storing src ensures - if (T is a dlib::matrix) then - #dest == src (if dest is just a normal matrix then this function just does a normal copy) - else - dest is a sparse vector and this function copies src into it. The assignment is performed such that the following is true: for all i: if (src(i) != 0) then make_pair(i, src(i)) is an element of #dest - #dest will be properly sorted !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename U> typename T::value_type::second_type dot ( const T& a, const U& b ); /*! requires - a is a sorted range of std::pair objects - b is a sorted range of std::pair objects ensures - returns the dot product between the vectors a and b !*/ // ---------------------------------------------------------------------------------------- template <typename T> typename T::value_type::second_type length_squared ( const T& a ); /*! requires - a is a sorted range of std::pair objects ensures - returns dot(a,a) !*/ // ---------------------------------------------------------------------------------------- template <typename T> typename T::value_type::second_type length ( const T& a ); /*! requires - a is a sorted range of std::pair objects ensures - returns std::sqrt(length_squared(a,a)) !*/ // ---------------------------------------------------------------------------------------- template <typename T, typename U> void scale_by ( T& a, const U& value ); /*! requires - a is a sorted range of std::pair objects ensures - #a == a*value (i.e. multiplies every element of the vector a by value) !*/ } // ---------------------------------------------------------------------------------------- /*!A has_unsigned_keys This is a template where has_unsigned_keys<T>::value == true when T is a sparse vector that contains unsigned integral keys and false otherwise. !*/ template <typename T> struct has_unsigned_keys { static const bool value = is_unsigned_type<typename T::value_type::first_type>::value; }; // ---------------------------------------------------------------------------------------- } #endif // DLIB_SVm_SPARSE_VECTOR_ABSTRACT_