gen3.cpp

#include <stdio.h>
#include <vector>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <cassert>

struct Input {

    FILE* file;

    std::vector<char> buffer;

    int pos;

    Input(FILE* file_, const int size_ = 1024*1024)
        : file(file_)
        , buffer(size_, '\0')
        , pos(0)
    {
        int size = fread(&buffer[0], 1, (int)buffer.size(), file);
        buffer.resize(size);
    }

    inline char get_char() {
        if (pos == (int)buffer.size()) {
            int size = fread(&buffer[0], 1, (int)buffer.size(), file);
            buffer.resize(size);
            pos = 0;
        }
        if (pos == (int)buffer.size()) {
            return EOF;
        }
        return buffer[pos++];
    }

    inline int get_int() {
        char c = '?';
        while (!(c == '-' || ('0' <= c && c <= '9'))) c = get_char();
        bool positive = true;
        if (c == '-') {
            positive = false;
            c = get_char();
        }
        int answ = 0;
        while ('0' <= c && c <= '9') { (answ *= 10) += (c - '0'); c = get_char(); }
        return positive ? answ : -answ;
    }

    inline long long get_ll() {
        char c = '?';
        while (!(c == '-' || ('0' <= c && c <= '9'))) c = get_char();
        bool positive = true;
        if (c == '-') {
            positive = false;
            c = get_char();
        }
        long long answ = 0;
        while ('0' <= c && c <= '9') { (answ *= 10) += (c - '0'); c = get_char(); }
        return positive ? answ : -answ;
    }

    inline double get_dbl() {
        char c = '?';
        while (!(c == '-' || ('0' <= c && c <= '9'))) c = get_char();
        bool positive = true;
        if (c == '-') {
            positive = false;
            c = get_char();
        }
        long long first = 0;
        while ('0' <= c && c <= '9') { (first *= 10) += (c - '0'); c = get_char(); }
        if (c != '.') {
            return double(positive ? first : -first);
        }
        c = get_char();
        long long second = 0;
        long long pow = 1;
        while ('0' <= c && c <= '9') { (second *= 10) += (c - '0'); c = get_char(); pow *= 10; }
        double answ = first + (double)second / (double)pow;
        return positive ? answ : -answ;
    }
};

struct Output {

    FILE* file;

    std::vector<char> buffer;

    int pos;

    Output(FILE* file_, const int size_ = 1024*1024)
        : file(file_)
        , buffer(size_, '\0')
        , pos(0)
    { }

    inline void flush() {
        put_char(-1);
    }

    inline void put_char(char c) {
        if (pos == (int)buffer.size() || c == -1) {
            fwrite(&buffer[0], 1, pos, file);
            pos = 0;
        }
        if (c != -1) {
    buffer[pos++] = c;
        }
    }

    inline void put_int(int value, int len = 0) {
        if (value < 0) {
            put_char('-');
            value = -value;
        }
        char buf[12]; int p = 0;
        do {
            buf[p++] = char(value % 10 + '0');
            value /= 10;
        } while (value > 0);
        while (p < len) buf[p++] = '0';
        while (p > 0) put_char(buf[--p]);
    }

    inline void put_ll(long long value, int len = 0) {
        if (value < 0) {
            put_char('-');
            value = -value;
        }
        char buf[12]; int p = 0;
        do {
            buf[p++] = char(value % 10 + '0');
            value /= 10;
        } while (value > 0);
        while (p < len) buf[p++] = '0';
        while (p > 0) put_char(buf[--p]);
    }

    inline void put_dbl(double value, int precision = 6) {
        if (value < 0) {
            put_char('-');
            value = -value;
        }

        put_ll((long long)value);
        value -= (long long)value;

        if (precision == 0) {
            return;
        }

        put_char('.');
        while (precision >= 6) {
            value *= 1000000;
            put_int((int)value, 6);
            value -= (int)value;
            precision -= 6;
        }
        while (precision >= 3) {
            value *= 1000;
            put_int((int)value, 3);
            value -= (int)value;
            precision -= 3;
        }
        while (precision >= 1) {
            value *= 10;
            put_char(char((int)value+'0'));
            value -= (int)value;
            precision--;
        }
    }

    ~Output() {
        flush();
    }
};

typedef long long ll;

ll get_ll() {
    ll answ = 0;
    for (int i = 0; i < 6; ++i) (answ *= 1000) += std::rand() % 1000;
    assert(0 <= answ && answ <= 1e18L);
    return answ;
}

int main() {

    const int n = 4*1000*1000;

    // Gen vector of 4kk integers:
    std::vector<int> arr_int(n);
    for (auto& it : arr_int) {
        it = int(get_ll() % (int)1e9);
    }

    // Gen vector of 4kk long long:
    std::vector<ll> arr_ll(n);
    for (auto& it : arr_ll) {
        it = get_ll();
    }

    // Gen vector of 4kk double:
    std::vector<double> arr_dbl(n);
    for (auto& it : arr_dbl) {
        it = (double)get_ll() / 1e9;
    }

    double time[2][3] = {};

    // fread / fwrite output

    {
        double t = clock();
        FILE* file = fopen("file_int.txt", "wt");

        Output out(file);

        out.put_int(n);
        out.put_char('\n');

        for (auto& it : arr_int) {
            out.put_int(it);
            out.put_char(' ');
        }
        out.flush();
        fclose(file);
        time[1][0] = (clock() - t) / CLOCKS_PER_SEC;
    }

    {
        double t = clock();
        FILE* file = fopen("file_ll.txt", "wt");

        Output out(file);

        out.put_int(n);
        out.put_char('\n');

        for (auto& it : arr_ll) {
            out.put_ll(it);
            out.put_char(' ');
        }
        out.flush();
        fclose(file);
        time[1][1] = (clock() - t) / CLOCKS_PER_SEC;
    }

    {
        double t = clock();
        FILE* file = fopen("file_dbl.txt", "wt");

        Output out(file);

        out.put_int(n);
        out.put_char('\n');

        for (auto& it : arr_dbl) {
            out.put_dbl(it);
            out.put_char(' ');
        }
        out.flush();
        fclose(file);
        time[1][2] = (clock() - t) / CLOCKS_PER_SEC;
    }

    // fread / fwrite output

    {
        double t = clock();
        FILE* file = fopen("file_int.txt", "rt");

        Input in(file);

        int size = in.get_int();
        arr_int.resize(size);

        for (auto& it : arr_int) {
            it = in.get_int();
        }

        fclose(file);
        time[0][0] = (clock() - t) / CLOCKS_PER_SEC;
    }

    {
        double t = clock();
        FILE* file = fopen("file_ll.txt", "rt");

        Input in(file);

        int size = in.get_int();
        arr_ll.resize(size);

        for (auto& it : arr_ll) {
            it = in.get_ll();
        }

        fclose(file);
        time[0][1] = (clock() - t) / CLOCKS_PER_SEC;
    }

    {
        double t = clock();
        FILE* file = fopen("file_ll.txt", "rt");

        Input in(file);

        int size = in.get_int();
        arr_dbl.resize(size);

        for (auto& it : arr_dbl) {
            it = in.get_dbl();
        }

        fclose(file);
        time[0][2] = (clock() - t) / CLOCKS_PER_SEC;
    }


    std::cout << "\n--- fread / fwrite - 4kk I/O speed test ---";
    std::cout << "\n-------------------------------------------";
    std::cout << "\n               type |    fread |    write |";
    std::cout << "\n-------------------------------------------";
    std::cout << "\n                int |"; for (int i = 0; i < 2; ++i) std::cout << std::setprecision(3) << std::setw(9) << std::fixed << time[i][0] << " |";
    std::cout << "\n          long long |"; for (int i = 0; i < 2; ++i) std::cout << std::setprecision(3) << std::setw(9) << std::fixed << time[i][1] << " |";
    std::cout << "\n             double |"; for (int i = 0; i < 2; ++i) std::cout << std::setprecision(3) << std::setw(9) << std::fixed << time[i][2] << " |";
    std::cout << "\n-------------------------------------------";
    std::cout << std::endl;



    return 0;
}