GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r643:5ccc65b48599

Updates sort() method to be compatible with a single vector

Alexandre Leroux -

r643:5ccc65b48599

parent child

Context file:

r643:5ccc65b48599

Collapse all files

core/include/Common/SortUtils.h +28 -6

             #ifndef SCIQLOP_SORTUTILS_H
             #define SCIQLOP_SORTUTILS_H
             #include <algorithm>
             #include <cmath>
             #include <numeric>
             #include <vector>
             /**
              * Utility class with methods for sorting data
              */
             struct SortUtils {
                 /**
                  * Generates a vector representing the index of insertion of each data of a container if this
                  * one had to be sorted according to a comparison function.
                  *
                  * For example:
                  * If the container is a vector {1; 4; 2; 5; 3} and the comparison function is std::less, the
                  * result would be : {0; 3; 1; 4; 2}
                  *
                  * @tparam Container the type of the container.
                  * @tparam Compare the type of the comparison function
                  * @param container the container from which to generate the result. The container must have a
                  * at() method that returns a value associated to an index
                  * @param compare the comparison function
                  */
                 template <typename Container, typename Compare>
                 static std::vector<int> sortPermutation(const Container &container, const Compare &compare)
                 {
                     auto permutation = std::vector<int>{};
                     permutation.resize(container.size());
                     std::iota(permutation.begin(), permutation.end(), 0);
                     std::sort(permutation.begin(), permutation.end(),
                               [&](int i, int j) { return compare(container.at(i), container.at(j)); });
                     return permutation;
                 }
                 /**
-                 * Sorts a container according to indices passed in parameter
+                 * Sorts a container according to indices passed in parameter. The number of data in the
+                 * container must be a multiple of the number of indices used to sort the container.
+                 *
+                 * Example 1:
+                 * container: {1, 2, 3, 4, 5, 6}
+                 * sortPermutation: {1, 0}
+                 *
+                 * Values will be sorted three by three, and the result will be:
+                 * {4, 5, 6, 1, 2, 3}
+                 *
+                 * Example 2:
+                 * container: {1, 2, 3, 4, 5, 6}
+                 * sortPermutation: {2, 0, 1}
+                 *
+                 * Values will be sorted two by two, and the result will be:
+                 * {5, 6, 1, 2, 3, 4}
+                 *
                  * @param container the container sorted
                  * @param sortPermutation the indices used to sort the container
                  * @return the container sorted
                  * @warning no verification is made on validity of sortPermutation (i.e. the vector has unique
                  * indices and its range is [0 ; vector.size()[ )
                  */
                 template <typename Container>
-                static Container sort(const Container &container, const std::vector<int> &sortPermutation)
+                static Container sort(const Container &container, int nbValues,
+                                      const std::vector<int> &sortPermutation)
                 {
-                    if (container.size() != sortPermutation.size()) {
+                    auto containerSize = container.size();
+                    if (containerSize % nbValues != 0
+                        || ((containerSize / nbValues) != sortPermutation.size())) {
                         return Container{};
                     }
                     // Inits result
                     auto sortedData = Container{};
-                    sortedData.resize(container.size());
+                    sortedData.reserve(containerSize);
-                    std::transform(sortPermutation.cbegin(), sortPermutation.cend(), sortedData.begin(),
+                    for (auto i = 0, componentIndex = 0, permutationIndex = 0; i < containerSize;
-                                   [&container](int i) { return container.at(i); });
+                         ++i, componentIndex = i % nbValues, permutationIndex = i / nbValues) {
+                        auto insertIndex = sortPermutation.at(permutationIndex) * nbValues + componentIndex;
+                        sortedData.append(container.at(insertIndex));
+                    }
                     return sortedData;
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching min value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 1
                  * - f({NaN, 3, 2, 4, 5}) will return 2 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::min_element
                  */
                 template <typename T>
                 static bool minCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> false
                     // v1 < NaN -> true
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? false : std::isnan(v2) || (v1 < v2);
                 }
                 /**
                  * Compares two values that can be NaN. This method is intended to be used as a compare function
                  * for searching max value by excluding NaN values.
                  *
                  * Examples of use:
                  * - f({1, 3, 2, 4, 5}) will return 5
                  * - f({1, 3, 2, 4, NaN}) will return 4 (NaN is excluded)
                  * - f({NaN, NaN, 3, NaN, NaN}) will return 3 (NaN are excluded)
                  * - f({NaN, NaN, NaN, NaN, NaN}) will return NaN (no existing value)
                  *
                  * @param v1 first value
                  * @param v2 second value
                  * @return true if v1 < v2, false otherwise
                  * @sa std::max_element
                  */
                 template <typename T>
                 static bool maxCompareWithNaN(const T &v1, const T &v2)
                 {
                     // Table used with NaN values:
                     // NaN < v2 -> true
                     // v1 < NaN -> false
                     // NaN < NaN -> false
                     // v1 < v2 -> v1 < v2
                     return std::isnan(v1) ? true : !std::isnan(v2) && (v1 < v2);
                 }
             };
             #endif // SCIQLOP_SORTUTILS_H

core/include/Data/ArrayData.h +6 -11

             #ifndef SCIQLOP_ARRAYDATA_H
             #define SCIQLOP_ARRAYDATA_H
             #include "Data/ArrayDataIterator.h"
             #include <Common/SortUtils.h>
             #include <QReadLocker>
             #include <QReadWriteLock>
             #include <QVector>
             #include <memory>
             template <int Dim>
             class ArrayData;
             using DataContainer = QVector<double>;
             namespace arraydata_detail {
             /// Struct used to sort ArrayData
             template <int Dim>
             struct Sort {
-                static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data,
+                static std::shared_ptr<ArrayData<Dim> > sort(const DataContainer &data, int nbComponents,
                                                              const std::vector<int> &sortPermutation)
                 {
-                    auto nbComponents = data.size();
+                    return std::make_shared<ArrayData<Dim> >(
-                    auto sortedData = DataContainer(nbComponents);
+                        SortUtils::sort(data, nbComponents, sortPermutation), nbComponents);
-                    for (auto i = 0; i < nbComponents; ++i) {
-                        sortedData[i] = SortUtils::sort(data.at(i), sortPermutation);
-                    return std::make_shared<ArrayData<Dim> >(std::move(sortedData));
                 }
             };
             /// Specialization for uni-dimensional ArrayData
             template <>
             struct Sort<1> {
-                static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data,
+                static std::shared_ptr<ArrayData<1> > sort(const DataContainer &data, int nbComponents,
                                                            const std::vector<int> &sortPermutation)
                 {
-                    return std::make_shared<ArrayData<1> >(SortUtils::sort(data.at(0), sortPermutation));
+                    Q_UNUSED(nbComponents)
+                    return std::make_shared<ArrayData<1> >(SortUtils::sort(data, 1, sortPermutation));
                 }
             };
             template <int Dim>
             class IteratorValue : public ArrayDataIteratorValue::Impl {
             public:
                 explicit IteratorValue(const DataContainer &container, bool begin) : m_Its{}
                 {
                     for (auto i = 0; i < container.size(); ++i) {
                         m_Its.push_back(begin ? container.at(i).cbegin() : container.at(i).cend());
                     }
                 }
                 IteratorValue(const IteratorValue &other) = default;
                 std::unique_ptr<ArrayDataIteratorValue::Impl> clone() const override
                 {
                     return std::make_unique<IteratorValue<Dim> >(*this);
                 }
                 bool equals(const ArrayDataIteratorValue::Impl &other) const override try {
                     const auto &otherImpl = dynamic_cast<const IteratorValue &>(other);
                     return m_Its == otherImpl.m_Its;
                 }
                 catch (const std::bad_cast &) {
                     return false;
                 }
                 void next() override
                 {
                     for (auto &it : m_Its) {
                         ++it;
                     }
                 }
                 void prev() override
                 {
                     for (auto &it : m_Its) {
                         --it;
                     }
                 }
                 double at(int componentIndex) const override { return *m_Its.at(componentIndex); }
                 double first() const override { return *m_Its.front(); }
                 double min() const override
                 {
                     auto end = m_Its.cend();
                     auto it = std::min_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
                         return SortUtils::minCompareWithNaN(*it1, *it2);
                     });
                     return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
                 }
                 double max() const override
                 {
                     auto end = m_Its.cend();
                     auto it = std::max_element(m_Its.cbegin(), end, [](const auto &it1, const auto &it2) {
                         return SortUtils::maxCompareWithNaN(*it1, *it2);
                     });
                     return it != end ? **it : std::numeric_limits<double>::quiet_NaN();
                 }
             private:
                 std::vector<DataContainer::value_type::const_iterator> m_Its;
             };
             } // namespace arraydata_detail
             /**
              * @brief The ArrayData class represents a dataset for a data series.
              *
              * A dataset can be unidimensional or two-dimensional. This property is determined by the Dim
              * template-parameter. In a case of a two-dimensional dataset, each dataset component has the same
              * number of values
              *
              * @tparam Dim the dimension of the ArrayData (one or two)
              * @sa IDataSeries
              */
             template <int Dim>
             class ArrayData {
             public:
                 // ///// //
                 // Ctors //
                 // ///// //
                 /**
                  * Ctor for a unidimensional ArrayData
                  * @param data the data the ArrayData will hold
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 explicit ArrayData(DataContainer data) : m_Data{std::move(data)}, m_NbComponents{1}
                 {
                 }
                 /**
                  * Ctor for a two-dimensional ArrayData. The number of components (number of lines) must be
                  * greater than 2 and must be a divisor of the total number of data in the vector
                  * @param data the data the ArrayData will hold
                  * @param nbComponents the number of components
                  * @throws std::invalid_argument if the number of components is less than 2 or is not a divisor
                  * of the size of the data
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 2> >
                 explicit ArrayData(DataContainer data, int nbComponents)
                         : m_Data{std::move(data)}, m_NbComponents{nbComponents}
                 {
                     if (nbComponents < 2) {
                         throw std::invalid_argument{
                             QString{"A multidimensional ArrayData must have at least 2 components (found: %1)"}
                                 .arg(nbComponents)
                                 .toStdString()};
                     }
                     if (m_Data.size() % m_NbComponents != 0) {
                         throw std::invalid_argument{QString{
                             "The number of components (%1) is inconsistent with the total number of data (%2)"}
                                                         .arg(m_Data.size(), nbComponents)
                                                         .toStdString()};
                     }
                 }
                 /// Copy ctor
                 explicit ArrayData(const ArrayData &other)
                 {
                     QReadLocker otherLocker{&other.m_Lock};
                     m_Data = other.m_Data;
                     m_NbComponents = other.m_NbComponents;
                 }
                 // /////////////// //
                 // General methods //
                 // /////////////// //
                 /**
                  * Merges into the array data an other array data. The two array datas must have the same number
                  * of components so the merge can be done
                  * @param other the array data to merge with
                  * @param prepend if true, the other array data is inserted at the beginning, otherwise it is
                  * inserted at the end
                  */
                 void add(const ArrayData<Dim> &other, bool prepend = false)
                 {
                     QWriteLocker locker{&m_Lock};
                     QReadLocker otherLocker{&other.m_Lock};
                     if (m_NbComponents != other.componentCount()) {
                         return;
                     }
                     if (prepend) {
                         auto otherDataSize = other.m_Data.size();
                         m_Data.insert(m_Data.begin(), otherDataSize, 0.);
                         for (auto i = 0; i < otherDataSize; ++i) {
                             m_Data.replace(i, other.m_Data.at(i));
                         }
                     }
                     else {
                         m_Data.append(other.m_Data);
                     }
                 }
                 void clear()
                 {
                     QWriteLocker locker{&m_Lock};
                     m_Data.clear();
                 }
                 int componentCount() const noexcept { return m_NbComponents; }
                 /// @return the size (i.e. number of values) of a single component
                 /// @remarks in a case of a two-dimensional ArrayData, each component has the same size
                 int size() const
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data.size() / m_NbComponents;
                 }
                 std::shared_ptr<ArrayData<Dim> > sort(const std::vector<int> &sortPermutation)
                 {
                     QReadLocker locker{&m_Lock};
                     return arraydata_detail::Sort<Dim>::sort(m_Data, m_NbComponents, sortPermutation);
                 }
                 // ///////// //
                 // Iterators //
                 // ///////// //
                 ArrayDataIterator cbegin() const
                 {
                     return ArrayDataIterator{ArrayDataIteratorValue{
                         std::make_unique<arraydata_detail::IteratorValue<Dim> >(m_Data, true)}};
                 }
                 ArrayDataIterator cend() const
                 {
                     return ArrayDataIterator{ArrayDataIteratorValue{
                         std::make_unique<arraydata_detail::IteratorValue<Dim> >(m_Data, false)}};
                 }
                 // ///////////// //
                 // 1-dim methods //
                 // ///////////// //
                 /**
                  * @return the data at a specified index
                  * @remarks index must be a valid position
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 double at(int index) const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data.at(index);
                 }
                 /**
                  * @return the data as a vector, as a const reference
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 const QVector<double> &cdata() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data.at(0);
                 }
                 /**
                  * @return the data as a vector
                  * @remarks this method is only available for a unidimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 1> >
                 QVector<double> data() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data[0];
                 }
                 // ///////////// //
                 // 2-dim methods //
                 // ///////////// //
                 /**
                  * @return the data
                  * @remarks this method is only available for a two-dimensional ArrayData
                  */
                 template <int D = Dim, typename = std::enable_if_t<D == 2> >
                 DataContainer data() const noexcept
                 {
                     QReadLocker locker{&m_Lock};
                     return m_Data;
                 }
             private:
                 DataContainer m_Data;
                 /// Number of components (lines). Is always 1 in a 1-dim ArrayData
                 int m_NbComponents;
                 mutable QReadWriteLock m_Lock;
             };
             #endif // SCIQLOP_ARRAYDATA_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

		sortedData[i] =
		resize ?

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages