Попытка суммировать две последовательности целочисленного набора времени компиляции

Question

Если вы отслеживаете мою историю вопроса, я обновляю библиотеку пространственного анализа ради того, чтобы качать кошмар макросов и изучать C++ 11, вариативные шаблоны, и метапрограммирование и парадигмы функционального программирования. Для моей жизни это все еще волшебство.

Во всяком случае, у меня есть кортежи констант экспоненты, которые определяют физические единицы.

template<int... I> 
using make_dimension = std::tuple<std::ratio<I>...>; 

using scalar_dimension = make_dimension<0, 0, 0, 0, 0, 0, 0>; 
using length_dimension = make_dimension<1, 0, 0, 0, 0, 0, 0>; 
using time_dimension = make_dimension<0, 0, 1, 0, 0, 0, 0>; 

Это (часть) библиотеки, которая моделирует единицы СИ. Вы можете умножать только единицы, в отличие от единиц, вы можете дополнительно добавить единицы и скаляры. Эти библиотеки денди в том, что они вызывают ошибки во время компиляции, если вы неправильно смешиваете блоки. Есть> 400 единиц, и большинство из них определяются с точки зрения других единиц. При умножении единиц измерения экспоненты добавляются, а при разделении единиц экспоненты вычитаются. Таким образом, чтобы определить скорость, я хотел бы средством выражения:

using velocity_dimension = divide_dimensions<length_dimension, time_dimension>; 

И это должно быть функционально эквивалентно записи:

using velocity_dimension = make_dimension<1, 0, -1, 0, 0, 0, 0>; 

Я погуглить, но я просто не знаю, терминология, чтобы приземлить некоторые хиты. Самое близкое, что я нашел, - это for_each, который применяет функцию к элементам кортежа во время выполнения ... И это как бы раздувает мой разум, поэтому я не могу понять, как превратить его в итерацию времени компиляции элементы. «make_dimension» выше было объяснено мне минуту назад, и это взорвало мой разум, но я выздоровел. Я как бы прошу просить раздаточный материал, и у кого-нибудь есть хорошие ресурсы для изучения этого материала? Я с трудом верю, что я единственный, кто очень заинтересован в этом.

Answer 1

@ Решение dyp в комментариях использует рекурсивно созданный шаблон. Несмотря на то, что это одна из наиболее общих методов переменных числа шаблонов, в этом случае рекурсия, вероятно, излишняя, поскольку весь набор преобразований может быть выполнен в одном пакете расширении, который расширяет два параметра пакеты одновременно:

template<template<class, class> class, class, class> 
struct tuple_transform; // undefined 

template<template<class, class> class Transform, class...Ts, class...Vs> 
struct tuple_transform<Transform, std::tuple<Ts...>, std::tuple<Vs...>> { 
    using type = std::tuple<Transform<Ts, Vs>...>; 
}; 

template<class T, class U> 
using divide_dimensions = typename tuple_transform<std::ratio_subtract, T, U>::type; 

Обратите внимание, что вышесказанное предполагает, что Transform<T, U> является псевдонимом для желаемого результирующего типа. Это соответствует поведению ratio_add и т. Д. - они являются шаблонами псевдонимов для полученного std::ratio, поэтому typename ratio_add<...>::type не требуется.

Demo.

Answer 2

У меня недостаточно информации, но похоже, что (1,0, -2,0,0,0,0) было бы то, что вам нужно для ускорения. 1 представляет метры, а-2 будет представлять собой разделение по секундам в квадрате, как это делает отрицательный показатель в математике.

Answer 3

Ответ на вопрос T.C.s правильный, вы можете просто взять std::integer_sequence (который является C++ 14, но может быть просто реализован) вместо отношения и кортежа, которые (по моему мнению) не подходят и не используют конструктор constexpr для манипуляций. Теперь ваш код должен выглядеть следующим образом (я не пробовал компилировать):

template<int... I> 
using make_dimension = std::integer_sequence<int, I...>; 

template<class Functor, class Dim1, class Dim2> 
struct transfrom; 

template<class Functor, int... Dims1, int... Dims2> 
struct transform< 
    Functor, 
    std::integer_sequence<int, Dims1...>, 
    std::integer_sequence<int, Dims2...> 
> { 
    static_assert(sizeof...(Dims1)==sizeof...(Dims2), "wrong dimensions"); 
    static constexpr Functor f; 
    using type=std::integer_sequence<int, f(Dims1,Dims2)...>; 
}; 

struct add { 
    constexpr int operator()(int l, int r) const { return l+r; } 
}; 
struct sub { 
    constexpr int operator()(int l, int r) const { return l-r; } 
}; 

template<class T, class U> 
using divide_dimensions = typename transform<sub, T, U>::type;