ostream checker improved; randomUnique

Author: ifsmirnov

array.h

@@ -8,8 +8,6 @@
 
 namespace impl {
 
-typedef std::pair<size_t, size_t> Range;
-
 template<typename T>
 class GenericArray : public Repr<GenericArray<T>>, public std::vector<T>  {
 public:
@@ -36,10 +34,10 @@ class GenericArray : public Repr<GenericArray<T>>, public std::vector<T>  {
     using Base::begin;
     using Base::end;
 
-    static GenericArray<T> random(size_t size, T max);
-    static GenericArray<T> random(size_t size, T min, T max);
-    static GenericArray<T> random(const Range& size, T max);
-    static GenericArray<T> random(const Range& size, T min, T max);
+    template<typename ...Args>
+    static GenericArray<T> random(size_t size, const Args& ... args);
+    template<typename ...Args>
+    static GenericArray<T> randomUnique(size_t size, const Args& ... args);
 
     static GenericArray<T> id(size_t size, T start = T{});
 
@@ -69,57 +67,63 @@ class GenericArray : public Repr<GenericArray<T>>, public std::vector<T>  {
 };
 
 template<typename T>
-GenericArray<T> GenericArray<T>::random(size_t size, T max) {
-    GenericArray<T> result(size);
-    for (T& x: result) {
-        x = rnd.next(max);
-    }
-    return result;
-}
-
-template<typename T>
-GenericArray<T> GenericArray<T>::random(size_t size, T min, T max) {
+template<typename ...Args>
+GenericArray<T> GenericArray<T>::random(size_t size, const Args& ... args) {
     GenericArray<T> result(size);
     for (T& x: result) {
-        x = rnd.next(min, max);
+        x = rnd.next(args...);
     }
     return result;
 }
 
-template<typename T>
-GenericArray<T> GenericArray<T>::random(const Range& size, T max) {
-    return random(rnd.next(size.first, size.second), max);
-}
+namespace detail {
 
-template<typename T>
-GenericArray<T> GenericArray<T>::random(const Range& size, T min, T max) {
-    return random(rnd.next(size.first, size.second), min, max);
-}
+template<typename T, typename Enable = std::size_t>
+struct DictContainer {
+    typedef std::set<T> type;
+};
 
 template<typename T>
-auto genericArrayIdHelper(size_t size, T start)
-    -> typename std::enable_if<
-        std::is_integral<T>::value, GenericArray<T>
-    >::type
+struct DictContainer<T, typename std::hash<T>::result_type>
 {
-    GenericArray<T> result(size);
-    std::iota(result.begin(), result.end(), start);
-    return result;
-}
+    typedef std::unordered_set<T> type;
+};
+
+} // namespace detail
 
 template<typename T>
-auto genericArrayIdHelper(size_t size, const T& start)
-    -> typename std::enable_if<
-        !std::is_integral<T>::value, GenericArray<T>
-    >::type
+template<typename ...Args>
+GenericArray<T> GenericArray<T>::randomUnique(
+        size_t size, const Args& ... args)
 {
-    ensure("Cannot take GenericArray<T>::id() when T is non-integral");
-    return {};
+    typename detail::DictContainer<T>::type set;
+    std::cerr << "using " << typeid(set).name() << std::endl;
+    GenericArray<T> result;
+    result.reserve(size);
+
+    while (result.size() != size) {
+        T t = rnd.next(args...);
+        if (!set.count(t)) {
+            set.insert(t);
+            result.push_back(t);
+        }
+    }
+
+    return result;
 }
 
 template<typename T>
 GenericArray<T> GenericArray<T>::id(size_t size, T start) {
-    return genericArrayIdHelper<T>(size, start);
+    constexpr bool enable = std::is_integral<T>::value;
+    static_assert(enable, "Cannot call Array<T>::id with non-integral T");
+
+    if (enable) {
+        GenericArray<T> result(size);
+        std::iota(result.begin(), result.end(), start);
+        return result;
+    } else {
+        return {};
+    }
 }
 
 template<typename T>
@@ -237,6 +241,7 @@ typedef GenericArray<double> Arrayf;
 
 } // namespace impl
 
+using impl::GenericArray;
 using impl::Array;
 using impl::Array64;
 using impl::Arrayf;

random.h

@@ -6,7 +6,6 @@ namespace impl {
 
 std::mt19937 randomEngine;
 
-__attribute__((constructor))
 static void assertRandomEngineConsistency() {
     std::mt19937 engine(1234);
     ensure(engine() == 822569775);
@@ -17,6 +16,7 @@ static void assertRandomEngineConsistency() {
 class Random {
 public:
     Random() {
+        assertRandomEngineConsistency();
         randomEngine.seed(std::random_device{}());
     }
 

repr.h

@@ -20,16 +20,7 @@ class Repr {
         return out;
     }
 
-    friend T;
-
-    // not sure if it would be needed ever
-    /*
-    friend Repr<T> repr(const T& t) {
-        return Repr<T>(t);
-    }
-    */
-
-private:
+protected:
     Repr() :
         object_(nullptr)
     {  }
@@ -83,15 +74,24 @@ class Has ## name ## Helper<T,\
     detail::Has ## name ## Helper<T>::value
 
 JNGEN_DEFINE_FUNCTION_CHECKER(
-    Ostream,
+    OstreamMethod,
     std::declval<std::ostream&>().operator<< (std::declval<T>())
 )
 
+JNGEN_DEFINE_FUNCTION_CHECKER(
+    OstreamFreeFunction,
+    std::operator<<(std::declval<std::ostream&>(), std::declval<T>())
+)
+
 JNGEN_DEFINE_FUNCTION_CHECKER(
     Plus,
     std::declval<T>() + 1
 )
 
+#define JNGEN_HAS_OSTREAM()\
+    (JNGEN_HAS_FUNCTION(OstreamMethod) ||\
+        JNGEN_HAS_FUNCTION(OstreamFreeFunction))
+
 template<typename T>
 struct VectorDepth {
     constexpr static int value = 0;
@@ -114,20 +114,20 @@ auto printValue(\
     std::ostream& out, const T& t, const OutputModifier& mod, PTag<priority>)\
     -> typename std::enable_if<constraint, void>::type
 
-JNGEN_DECLARE_PRINTER(!JNGEN_HAS_FUNCTION(Ostream), 0)
+JNGEN_DECLARE_PRINTER(!JNGEN_HAS_OSTREAM(), 0)
 {
     // can't just write 'false' here because assertion always fails
     static_assert(!std::is_same<T, T>::value, "operator<< is undefined");
 }
 
-JNGEN_DECLARE_PRINTER(JNGEN_HAS_FUNCTION(Ostream), 1)
+JNGEN_DECLARE_PRINTER(JNGEN_HAS_OSTREAM(), 1)
 {
     (void)mod;
     out << t;
 }
 
 JNGEN_DECLARE_PRINTER(
-    JNGEN_HAS_FUNCTION(Ostream) && JNGEN_HAS_FUNCTION(Plus), 2)
+    JNGEN_HAS_OSTREAM() && JNGEN_HAS_FUNCTION(Plus), 2)
 {
     out << t + mod.addition;
 }