moved all stuff to github

tests/difficulty/difficulty.cpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2012-2013 The Cryptonote developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "cryptonote_config.h"
+#include "cryptonote_core/difficulty.h"
+
+using namespace std;
+
+#define DEFAULT_TEST_DIFFICULTY_TARGET        120
+
+int main(int argc, char *argv[]) {
+    if (argc != 2) {
+        cerr << "Wrong arguments" << endl;
+        return 1;
+    }
+    vector<uint64_t> timestamps, cumulative_difficulties;
+    fstream data(argv[1], fstream::in);
+    data.exceptions(fstream::badbit);
+    data.clear(data.rdstate());
+    uint64_t timestamp, difficulty, cumulative_difficulty = 0;
+    size_t n = 0;
+    while (data >> timestamp >> difficulty) {
+        size_t begin, end;
+        if (n < DIFFICULTY_WINDOW + DIFFICULTY_LAG) {
+            begin = 0;
+            end = min(n, (size_t) DIFFICULTY_WINDOW);
+        } else {
+            end = n - DIFFICULTY_LAG;
+            begin = end - DIFFICULTY_WINDOW;
+        }
+        uint64_t res = cryptonote::next_difficulty(
+            vector<uint64_t>(timestamps.begin() + begin, timestamps.begin() + end),
+            vector<uint64_t>(cumulative_difficulties.begin() + begin, cumulative_difficulties.begin() + end), DEFAULT_TEST_DIFFICULTY_TARGET);
+        if (res != difficulty) {
+            cerr << "Wrong difficulty for block " << n << endl
+                << "Expected: " << difficulty << endl
+                << "Found: " << res << endl;
+            return 1;
+        }
+        timestamps.push_back(timestamp);
+        cumulative_difficulties.push_back(cumulative_difficulty += difficulty);
+        ++n;
+    }
+    if (!data.eof()) {
+        data.clear(fstream::badbit);
+    }
+    return 0;
+}

tests/difficulty/generate-data

@@ -0,0 +1,52 @@
+#!/usr/bin/python3
+
+from random import randint
+
+DIFFICULTY_TARGET = 120
+DIFFICULTY_WINDOW = 720
+DIFFICULTY_LAG = 15
+DIFFICULTY_CUT = 60
+
+UINT_MAX = (1 << 64) - 1
+
+def difficulty():
+    times = []
+    diffs = []
+    while True:
+        if len(times) <= 1:
+            diff = 1
+        else:
+            begin = max(len(times) - DIFFICULTY_WINDOW - DIFFICULTY_LAG, 0)
+            end = min(begin + DIFFICULTY_WINDOW, len(times))
+            length = end - begin
+            assert length >= 2
+            if length <= DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT:
+                cut_begin = 0
+                cut_end = length
+            else:
+                excess = length - (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT)
+                cut_begin = (excess + 1) // 2
+                cut_end = length - excess // 2
+            assert cut_begin + 2 <= cut_end
+            wnd = times[begin:end]
+            wnd.sort()
+            dtime = wnd[cut_end - 1] - wnd[cut_begin]
+            assert 0 <= dtime <= UINT_MAX
+            dtime = max(dtime, 1)
+            ddiff = sum(diffs[begin + cut_begin + 1:begin + cut_end])
+            assert 0 < ddiff <= UINT_MAX
+            assert dtime <= ddiff * DIFFICULTY_TARGET + dtime - 1 <= UINT_MAX
+            diff = (ddiff * DIFFICULTY_TARGET + dtime - 1) // dtime
+        assert 0 < diff <= UINT_MAX
+        times.append((yield diff))
+        diffs.append(diff)
+
+time = 1000
+gen = difficulty()
+diff = next(gen)
+for i in range(1000):
+    power = 10 if i < 100 else 10000 if i < 500 else 1000000
+    time += randint(-diff // power - 10, 3 * diff // power + 10)
+    assert 0 <= time <= UINT_MAX
+    print(time, diff)
+    diff = gen.send(time)