Order.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Array.h"
#include "objects/geometry/Indices.h"
#include <algorithm>
 
NAMESPACE_SPH_BEGIN
 
class Order : public Noncopyable {
private:
    Array<Size> storage;
 
    Order(Array<Size>&& other)
        : storage(std::move(other)) {}
 
public:
    Order() = default;
 
    Order(Order&& other)
        : storage(std::move(other.storage)) {}
 
    explicit Order(const Size n)
        : storage(0, n) {
        for (Size i = 0; i < n; ++i) {
            storage.push(i);
        }
    }
 
    Order& operator=(Order&& other) {
        storage = std::move(other.storage);
        return *this;
    }
 
    template <typename TBinaryPredicate>
    void shuffle(TBinaryPredicate&& predicate) {
        std::sort(storage.begin(), storage.end(), predicate);
    }
 
    Order getInverted() const {
        Array<Size> inverted(storage.size());
        for (Size i = 0; i < storage.size(); ++i) {
            inverted[storage[i]] = i;
        }
        return inverted;
    }
 
    Order clone() const {
        return storage.clone();
    }
 
    Order compose(const Order& other) const {
        Array<Size> composed(storage.size());
        for (Size i = 0; i < storage.size(); ++i) {
            composed[i] = storage[other[i]];
        }
        return composed;
    }
 
    template <typename T>
    Array<T> apply(const Array<T>& input) {
        Array<T> sorted(input.size());
        for (Size i = 0; i < input.size(); ++i) {
            sorted[i] = input[storage[i]];
        }
        return sorted;
    }
 
    INLINE Size operator[](const Size idx) const {
        return storage[idx];
    }
 
    INLINE Size size() const {
        return storage.size();
    }
 
    INLINE bool operator==(const Order& other) const {
        return storage == other.storage;
    }
};
 
template <typename TLess = std::less<Float>>
INLINE Order getOrder(ArrayView<const Float> values, const TLess less = TLess{}) {
    Order order(values.size());
    order.shuffle([values, &less](Size i, Size j) { return less(values[i], values[j]); });
    return order.getInverted();
}
 
 
NAMESPACE_SPH_END