Наносекунды и Chrono C ++ - PullRequest
4 голосов
/ 01 мая 2020
2018-10-01 00:06:16.700000000

У меня есть файл данных временных рядов с временными метками, как указано выше. Мне нужно преобразовать это в наносекунды с эпохи, затем мне нужно будет добавить милли, микро или наносигналы к отметке времени (сдвиг). Наконец, для избранных записей верните его в формат выше.

У меня проблемы с созданием точки времени - и как представить наносекунды ... Это отлично работает с микро.

Могу ли я попросить некоторую помощь с фрагментом кода ниже .... а также, как только я получу наносекунды из эпохи - как мне go вернуться к отметке времени, подобной приведенной выше.

std::string ts("23 01 2020 20:59:59.123456789");

XXXX (ts);

void XXXXX (string timestamp)
{
     stringstream temp_ss(timestamp);

     tm temp_time_object = {};

     temp_ss >> get_time (&temp_time_object, "%Y/%m/%d %H:%M:%S");

     chrono::system_clock::time_point temp_time_point = system_clock::from_time_t(mktime(&temp_time_object));
    // chrono::high_resolution_clock::time_point temp_time_point1 = temp_time_point;

    auto  nsecs           =  stol (timestamp.substr (timestamp.find_first_of('.')+1,9));

// +++ This is where I GET stuck forming the time_point....
// I've tried this so many different ways .... 
// Is it that the system_clock cannot accept nanos? 


    temp_time_point += nanoseconds (nsecs);

     auto micro_from_epoch = duration_cast<nanoseconds> (temp_time_point.time_since_epoch()).count();

     cout << micro_from_epoch << endl;

}

Ответы [ 2 ]

2 голосов
/ 01 мая 2020

У меня проблемы с созданием точки времени - и как представить наносекунды ... Она отлично работает с микроэлементами.

Это говорит мне о том, что ваш system_clock::time_point имеет точность грубее наносекунд (на 1 кв. м микросекунды, на Windows, 1/10 мкс). Самый простой способ добавить наносекунды к такому time_point:

auto tp = temp_time_point + nanoseconds (nsecs);

. Это формирует time_point, который все еще основан на system_clock, но имеет точность "общего типа" * 1012. * и nanoseconds, что на практике будет просто nanoseconds.

при условии, что все метки времени указаны по Гринвичу, UT C + 0

Теперь проблема является то, что mktime преобразуется из локального tm в UT C time_t. Но вы хотите преобразовать тип поля UT C в тип последовательного UT C.

Это легко сделать в C ++ 20 (я знаю, у вас его еще нет, выслушайте меня):

#include <chrono>
#include <iostream>
#include <sstream>

std::chrono::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = std::format("{:%F %T}", tp);
    std::cout << s << '\n';
}

Это преобразует string в chrono::time_point<system_clock, nanoseconds>, что, очевидно, отличается от вашего system_clock::time_point только тем, что ваш system_clock::time_point имеет точность более грубую, чем nanoseconds.

Затем format используется для преобразования time_point обратно в string.

Вывод:

1538352376700000000ns
2018-10-01 00:06:16.700000000

Теперь я знаю, что полностью соответствующий C ++ 20 <chrono> это редкая вещь в наши дни (она наступает). До тех пор, пока он не появится, существует C ++ 20 <chrono> библиотека предварительного просмотра , которая совместима с C ++ 11. Это бесплатно и с открытым исходным кодом. И требует очень мало изменений syntacti c:

#include "date/date.h"
#include <chrono>
#include <iostream>
#include <sstream>

date::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    using namespace date;
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = format("%F %T", tp);
    std::cout << s << '\n';
}

Выход:

1538352376700000000ns
2018-10-01 00:06:16.700000000
1 голос
/ 01 мая 2020

Вы работаете конвертировать прямо из текста в наносекундном разрешении. По сути, есть две ключевые библиотеки:

  • CCTZ некоторыми инженерами Google, хотя (как и многие проекты) не является официально выпущенным продуктом Google

  • дата Говарда Хиннанта, который, вероятно, ответит здесь, прежде чем я закончу печатать; его библиотека является основой для этого в C ++ 20

Я обернул оба для R (через R cpp) и имею множество примеров. Но есть также примеры в двух репозиториях, так что, может быть, начнем там?

Так что из-за отсутствия лучших непосредственных примеров CCTZ здесь один, где используется пакет R; вы видите входные данные:

R> library(RcppCCTZ)
R> example(parseDatetime)

prsDttR> ds <- getOption("digits.secs")

prsDttR> options(digits.secs=6) # max value

prsDttR> parseDatetime("2016-12-07 10:11:12",        "%Y-%m-%d %H:%M:%S")   # full seconds
[1] "2016-12-07 10:11:12 UTC"

prsDttR> parseDatetime("2016-12-07 10:11:12.123456", "%Y-%m-%d %H:%M:%E*S") # fractional seconds
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> parseDatetime("2016-12-07T10:11:12.123456-00:00")  ## default RFC3339 format
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> now <- trunc(Sys.time())

prsDttR> parseDatetime(formatDatetime(now + 0:4))               # vectorised
[1] "2020-05-01 02:16:27 UTC" "2020-05-01 02:16:28 UTC"
[3] "2020-05-01 02:16:29 UTC" "2020-05-01 02:16:30 UTC"
[5] "2020-05-01 02:16:31 UTC"

prsDttR> options(digits.secs=ds)
R> 

Вызванная функция синтаксического анализатора is (и игнорирует R связанные биты)

Rcpp::DatetimeVector parseDatetime(Rcpp::CharacterVector svec,
                                   std::string fmt = "%Y-%m-%dT%H:%M:%E*S%Ez",
                                   std::string tzstr = "UTC") {
    cctz::time_zone tz;
    load_time_zone(tzstr, &tz);
    sc::system_clock::time_point tp;
    cctz::time_point<cctz::sys_seconds> unix_epoch =
        sc::time_point_cast<cctz::sys_seconds>(sc::system_clock::from_time_t(0));

    // if we wanted a 'start' timer
    //sc::system_clock::time_point start = sc::high_resolution_clock::now();

    auto n = svec.size();
    Rcpp::DatetimeVector dv(n, tzstr.c_str());
    for (auto i=0; i<n; i++) {
        std::string txt(svec(i));

        if (!cctz::parse(fmt, txt, tz, &tp)) Rcpp::stop("Parse error on %s", txt);

        // time since epoch, with fractional seconds added back in
        // only microseconds guaranteed to be present
        double dt = sc::duration_cast<sc::microseconds>(tp - unix_epoch).count() * 1.0e-6;

        // Rcpp::Rcout << "tp: " << cctz::format(fmt, tp, tz) << "\n"
        //             << "unix epoch: " << cctz::format(fmt, unix_epoch, tz) << "\n"
        //             << "(tp - unix.epoch).count(): " << (tp - unix_epoch).count() << "\n"
        //             << "dt: " << dt << std::endl;

        dv(i) = Rcpp::Datetime(dt);
    }

    return dv;
}

Она просматривает входящий вектор svec строк и преобразует каждую .

Редактировать: Вот еще один пример использования нашего пакета nanotime , который использует и использует синтаксический анализатор CCTZ:

R> library(nanotime)
R> as.nanotime("2020-01-29 13:12:00.000000001 America/New_York")
[1] 2020-01-29T18:12:00.000000001+00:00
R> 

Full 9 + 9 точность цифр с использованием базовых наносекунд, начиная с эпохи, полностью совместимых с std::chrono.

...