flatten_t<> in O(1)?

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 20:34:53 GMT

5cript — Thu, 26 Nov 2015 20:34:53 GMT

Ich suche die Effizienteste (nach Rekursionstiefe) Implementierung für folgende Metafunktion:

using tup = std::tuple , long>;
using flat = flatten_t ; // -> std::tuple

meine pseudo lösung in O(n) [Rekursionstiefe].
EDIT: (mein if ist lazy)
EDIT: Die Pseudolösung nimmt auch kein tuple, sondern args. Aber das ist egal.

template 
struct flatten {
    using type = 
    if_ ::value, /* do merge with recursive flatten::type O(1) */, 
                              /* push_back / push_front with recursive flatten::type O(1) */>::type; 
};

template 
struct flatten  {
    using type = 
    if_ ::value, T, 
                              std::tuple  >::type
};

Ist das auch in konstanter Rekursionstiefe machbar?

EDIT: Das ist die tatsächliche Implementierung, aber da die eh niemand ausprobieren kann...

// fundamental
#include "../fundamental/eval_if.hpp"

// control
#include "../control/if.hpp"

// tuple
#include "../tuple/is_tuple.hpp"
#include "../tuple/concat.hpp"
#include "../tuple/apply.hpp"

// algorithm
#include "merge.hpp"

// functional
#include "../functional/lift.hpp"

namespace mplex
{
    namespace internal {
        struct flatten_impl;

        struct flatten_impl {
            template 
            struct apply
            {
                using _is_tuple = typename is_tuple::template apply ::type;
                using _is_not_tuple = bool_ ;

                using type = lazy_if_t <_is_tuple,
                                        then_ , Head, eval_if_default_t <_is_tuple, std::tuple<>, flatten_impl, Tail...>>,
                                        else_ , eval_if_default_t <_is_not_tuple, std::tuple<>, flatten_impl, Tail...>, Head>>;
            };

        };

        template 
        struct flatten_impl::apply  {
            using type = if_t ::type,
                               Head, std::tuple >;
        };
    }

    /**
     *  Flattens a tuple, but not deep.
     *
     *  std::tuple, double>
     *  becomes std::tuple
     *
     */
    template 
    struct flatten {
        using type = typename apply_t ::type;
    };

    template 
    using flatten_t = typename flatten ::type;
}

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 21:23:29 GMT

Columbo — Thu, 26 Nov 2015 21:23:29 GMT

Man kann logarithmische Tiefe erreichen. Ich denke, folgendes funktioniert - nur schnell heruntergetippt, geht wahrscheinlich viel eleganter (und effizienter):

#include 

template  struct identity {using type=T;};

template 
struct index_list {using type=index_list;};

template  using eval = typename T::type;

template  struct pack {};

template  constexpr std::size_t length=0;
template 
constexpr auto length> = sizeof...(xs);

template  struct duplicate;
template 
struct duplicate, index_list> : index_list {};

template 
struct make_index_list :
	duplicate< eval>,
	           eval> > {};

template <> struct make_index_list<1> : index_list<0> {};
template <> struct make_index_list<0> : index_list<> {};

template 
using make_index_list_t = eval>;

/// ////////////////////////////////////////////////////////////////////////////////////////

template 
struct type_node {using type=T;};
template 
identity type_deducer(type_node);

template >>
struct type_map;
template 
struct type_map, index_list> : type_node... {};

template 
using get_t = eval(M()))>;

/// ////////////////////////////////////////////////////////////////////////////////////////

template  struct cat;
template 
struct cat, pack> {using type=pack;};
template  using cat_t = eval>;

template >
struct flatten : cat::type, typename flatten::type> {};
template 
struct flatten {
	template  struct aux {using type=pack<_>;};
	template 
	struct aux> : flatten> {};

	using type = typename aux(type_map()))::type>::type;
};
template <> struct flatten, 0, 0> {using type=pack<>;};

template 
using flatten_t = eval>;

static_assert(std::is_same>, pack>>,
                                     pack>{});

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 21:09:35 GMT

5cript — Thu, 26 Nov 2015 21:09:35 GMT

Ich wusste du würdest antworten
Erster Eindruck: Holy ****

template  using eval = typename T::type;

Ist das eine Denksache?

template  struct pack {};

Ich muss auch nochmal umstellen.

Ich brauche glaube ich noch ein bisschen Zeit, bis ich den Code komplett verstanden habe ^^.

EDIT: ah, das ist viel hilfcode und nicht so viel zum eigentlichen problem.

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 21:41:13 GMT

Columbo — Thu, 26 Nov 2015 21:41:13 GMT

Habe den Code nochmal angepasst. Hilft aber alles nix. Läuft nämlich linear in der Länge der resultierenden Liste.

template 
struct construct {using type=pack::type>;};
template <>
struct construct<0> {using type=pack<>;};

using F = flatten_t::type>;

Packen GCC und Clang in genau 322 Instantiierungen, wobei die resultierende Liste aber 384 ist.
flatten_t::type> braucht exakt 643 Instantiierungen für eine doppelt so lange Liste.

Sorry, hab' mich nicht richtig mit dem Problem auseinandergesetzt. Habe ein paar Ideen, die ich mir anschauen werde.

Ich muss auch nochmal umstellen.

pack kompiliert deutlich schneller als tuple . Siehe e.g. hier, wo das verwenden von pack die Effizienz krass gesteigert hat.

ah, das ist viel hilfcode und nicht so viel zum eigentlichen problem.

Ja, ich wollte nämlich logarithmische Instantiierungstiefe für make_index_list , was Implementierungen von std::make_index_sequence in libc++ und libstdc++ momentan nicht vorzeigen können.

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 22:13:29 GMT

5cript — Thu, 26 Nov 2015 22:13:29 GMT

Packen GCC und Clang in genau 322 Instantiierungen, wobei die resultierende Liste aber 384 ist.
flatten_t::type> braucht exakt 643 Instantiierungen für eine doppelt so lange Liste.

Wie weißt du das so genau?

pack kompiliert deutlich schneller als tuple. Siehe e.g. hier, wo das verwenden von pack die Effizienz krass gesteigert hat.

Ja das habe ich vor ein paar Wochen gehört, vom boost Hana Schöpfer (in einem seiner talks).

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 22:16:55 GMT

Columbo — Thu, 26 Nov 2015 22:16:55 GMT

Habe mich vertan, es scheint, dass pro Schachtelungstiefe ein logarithmischer Overhead besteht. Hier wohl 5 - einer für aux , ein anderer für die Spezialisierung von type_deducer um auf den Typ zuzugreifen, und $\lceil \text{lb} 7 \rceil$ . Daher 5*128 = 640, plus drei Instantiierungen drum herum. Das scheint im Nachhinein von der Komplexität ziemlich optimal zu sein, schließlich brauchen wir auf jeder Ebene auch mindestens einen logarithmischen Overhead zum konkatenieren.

Eine Idee wäre zumindest, nur Indizen auf die packs zu speichern, diese dann parallel(!!!) zu flatten und anschließend die Konkatenierung der resultierenden packs und der ursprünglichen, nicht-pack Typen rekursiv vorzunehmen. Das werd' ich mir mal anschauen.

5cript schrieb:

Woher weißt du das so genau?

Du kannst eine Intervall schachtelnde Bash-Anweisung schreiben, die den Rückgabewert des Compilers als Vergleichsprädikat nimmt (1 => kleiner, 0 <= größer) und das Argument an -ftemplate-depth anpasst.

Reply to flatten_t<> in O(1)? on Thu, 26 Nov 2015 22:29:24 GMT

5cript — Thu, 26 Nov 2015 22:29:24 GMT

Du kannst eine Intervall schachtelnde Bash-Anweisung schreiben, die den Rückgabewert des Compilers als Vergleichsprädikat nimmt (1 => kleiner, 0 <= größer) und das Argument an -ftemplate-depth anpasst.

smart!

Reply to flatten_t<> in O(1)? on Fri, 27 Nov 2015 10:35:14 GMT

Columbo — Fri, 27 Nov 2015 10:35:14 GMT

Ja, meine Idee hat sehr geholfen. construct<64> braucht kaum mehr 76 Instantiierungen, construct<128> 140. Die Linearität in der Verschachtelungstiefe hat sich natürlich nicht geändert (immer noch $\Theta(n)$ ), was sich auch nicht ändern kann, aber wir haben nun einen Overhead, der logarithmisch in der Länge des längsten, rekursiv enthaltenen Packs wächst. I.e. wenn jedes pack in construct<64> stattdessen 32 Member hat, bekommen wir 78, was natürlich bei zwei zusätzlichen (binären) Größenordnungen über 8 ziemlich einleuchtend ist.

#include 

template  struct identity {using type=T;};

template 
struct index_list{
	using type=index_list;
	static constexpr std::size_t arr[] = {args...};
};

template  using eval = typename T::type;

template  struct pack {using type=pack;};

template  constexpr std::size_t length=0;
template 
constexpr auto length> = sizeof...(xs);

template  struct duplicate;
template 
struct duplicate, index_list> : index_list {};

template 
struct make_index_list :
	duplicate< eval>,
	           eval> > {};

template <> struct make_index_list<1> : index_list<0> {};
template <> struct make_index_list<0> : index_list<> {};

template 
using make_index_list_t = eval>;

template >
struct sub_list;
template 
struct sub_list> : index_list {};

/// ////////////////////////////////////////////////////////////////////////////////////////

template 
struct type_node {using type=T;};
template 
identity type_deducer(type_node);

template >>
struct type_map;
template 
struct type_map, index_list> : type_node... {};

template 
using get_t = typename decltype(type_deducer(M()))::type;
template 
using pack_get_t = typename decltype(type_deducer(type_map()))::type;

template >
struct sub_pack;
template 
struct sub_pack> : pack...> {};

/// /////////////////////////////////

template  struct cat;
template 
struct cat, pack> {using type=pack;};
template 
struct cat, index_list> {using type=index_list;};
template  using cat_t = eval>;

/// ////////////////////////////////////////////////////////////////////////////////////////

template  typename F, typename State>
struct reccat {
	template 
	struct apply : cat::type,
	                   typename apply::type> {};
	template 
	struct apply {using type=typename F::type;};
};
template  typename F, typename State, std::size_t L>
using reccat_t = typename reccat::template apply<0, L>::type;

/// ///////////////////////////////////

template 
struct getIndicesImpl {
	template  struct aux : index_list<> {};
	template 
	struct aux> : index_list {};

	using type = typename aux>::type;
};
template 
struct getIndices : reccat_t> {};
template <>
struct getIndices> : index_list<> {};

template ::type>
struct flatten;

template 
struct flatten>
{
	using flattened_packs = pack>::type...>;

	template 
	struct merge {
		static constexpr auto start_index = I==0? 0 : index_list::arr[I-1]+1;
		template ::arr[I] - start_index>>
		struct aux;
		template 
		struct aux> : cat...>,
		                                         pack_get_t> {};
		using type = eval>;
	};

	static constexpr auto tail_start_index = index_list::arr[sizeof...(pack_indices)-1]+1;
	using type = cat_t,
	                   typename sub_pack-tail_start_index>::type>;
};

template  struct flatten<_, index_list<>> {using type = _;};
template  struct flatten>, index_list<0>> {using type = eval>>;};

template 
using flatten_t = eval>;

/// TESTS:

static_assert(std::is_same, int>, pack, float>>,
                                     pack>{});

template 
struct construct {using type=pack::type, unsigned long>;};
template <>
struct construct<0> {using type=pack<>;};

using F = flatten_t::type>;

Reply to flatten_t<> in O(1)? on Fri, 27 Nov 2015 01:04:25 GMT

5cript — Fri, 27 Nov 2015 01:04:25 GMT

Oh mein Gott

Das versuch ich gar nicht mehr nachzuvollziehen
Das schafft ja sogar rekursiv (flatten_deep), wenn ich das richtige sehe.

Da bleibt mir nur noch Danke zu sagen.

EDIT: Man könnte vielleicht noch optimieren, wenn man die Reihenfolge außer Acht lässt, was aber zumindest in meinem Anwendungsfall leider nicht geht.
(Dafür hatte ich eine Idee mit pack expansion, habe aber den Gedanken noch nicht ganz zu Ende gebracht.).

Reply to flatten_t<> in O(1)? on Fri, 27 Nov 2015 01:42:02 GMT

Columbo — Fri, 27 Nov 2015 01:42:02 GMT

5cript schrieb:

Das schafft ja sogar rekursiv (flatten_deep), wenn ich das richtige sehe.

Na darum ging's doch?

Reply to flatten_t<> in O(1)? on Fri, 27 Nov 2015 07:44:39 GMT

5cript — Fri, 27 Nov 2015 07:44:39 GMT

Eine Ebene hätte auch (erstmal) gereicht