flisboac / adl Goto Github PK

So, github does not let me delete issues. Playing with the issues system in a final repository is out of question now. Lesson learned.

For use in CPU execution profiling.

So, github does not let me delete issues. Playing with the issues system in a final repository is out of question now. Lesson learned.

This module unit includes all of its inner modules in its main .hpp file. Also, an additional .cfg.hpp should be responsible for all preprocessor verifications, if any.

All of this module's types (e.g. namespace-level typedefs, classes, enums, structs, unions) must be forward-declared in the module's .fwd.hpp header. Inner artifacts (e.g. module, component) are prohibited to forward-declare types anywhere else.

File structure

• $PROJECT_ROOT/
  • include/
    • adl/util.hpp
    • adl/util.fwd.hpp

Dependencies

• #4

Signature:

template <
    typename ValueType
    typename ValueTraits>
template <
    std::size_t ArraySize,
    typename ValueType_, 
    template VarType_,
    template = std::enable_if_t<
        std::is_convertible<ValueType, ValueType_>::value
        && common_var<VarType_>::is_oct_space>
oct_cons<ValueType, ValueTraits>::oct_cons(
    oct_cons<ValueType_, VarType_>  (&constraints)[ArraySize]
);

template <
    typename ValueType
    typename ValueTraits>
template <
    std::size_t ArraySize,
    typename ValueType_, 
    template VarType_,
    template = std::enable_if_t<
        std::is_convertible<ValueType, ValueType_>::value
        && common_var<VarType_>::is_oct_space>
std::size_t insert(oct_cons<ValueType_, VarType_> (&constraints)[ArraySize]);

template <
    typename ValueType
    typename ValueTraits>
template <typename IterType>
std::size_t insert(IterType begin, IterType end);

Dependencies

• #6

Dependencies

• #21
• #20

Dependencies

• #6
• #31

The name of the classes and header files follow the names of the enum's constants.

Dependencies

• #6

Dependencies

• #18
• #16
• #17

Dependencies

• #11
• #17

Checklist

• adl/oct/var/oct_var
• adl/oct/var/octdiff_var

Dependencies

• #24
• #20
• #19

Checklist

• adl/oct/system/oct_system
• adl/oct/system/octdiff_system

Objectives

• Create the project's main infrastructure (e.g. folders and file patterns).
• Create the dotfiles.
• Create the build system's initial infrastructure.
• Ensure LICENSE reflects

Checklist

• LICENSE
• Doxyfile
• README
• CMake
• .gitignore
• .editorconfig

Also, all global operator<< would use this as an option. Preferably, to_string() would use to_string(std::ostream), to avoid duplicating code.

Should contain enumerations and values that globally apply to the octagon domain module or to the project as a whole.

Dependencies

• #6

Checklist

• Component Unit adl/error_code
• Component Unit adl/oct/domain_space
• Component Unit adl/oct/oper_kind
• Component Unit adl/oct/dbm_layout

Dependencies

• #6

Dependencies

• #6

Dependencies

• #12
• #17

The module unit adl includes all of the inner modules in the project. Every module unit has a main .hpp file. Also, an additional .cfg.hpp should be responsible for all preprocessor verifications, if any.

The following main sub-modules are contemplated in this first sprint:

• Module Unit adl
• Module Unit adl/oct
• Module Unit adl/util
• Module Unit adl/oct/dsl

All of the main sub-modules' types (e.g. namespace-level typedefs, classes, enums, structs, unions) must be forward-declared in the module's .fwd.hpp header. Inner artifacts (e.g. module, component) are prohibited to forward-declare types anywhere else.

File structure

• $PROJECT_ROOT/
  • include
    • adl.hpp
    • adl.fwd.hpp
    • adl.cfg.hpp
    • adl/
      • oct/
        • dsl/
        • dsl.hpp
      • util/
      • oct.hpp
      • oct.fwd.hpp
      • util.hpp
      • util.fwd.hpp

Dependencies

• #4

Dependencies

• #7
• #21

A timer that will be used for operator timing measures.

The API still needs to be fleshed out, but in a nutshell, it will use std::chrono functionality to measure timings on various places of interest in the algorithms.' Imagine:

adl::util::timer_list timers;
for (...) { // suppose 5 iterations
    timer.start();
    // (processing, suppose 5th was fastest)
    timer.stop();
}
timers.size(); // 5
timers.fastest(); // an adl::util::timer_list::entry
timers.slowest(); // an adl::util::timer_list::entry
timers.fastest().index(); // 4 (starts at 0)
timers.min(); // an adl::util::timer_list::entry
timers.max(); // an adl::util::timer_list::entry
timers.fastest().duration(); // a std::duration
timers.sum(); // a std::duration
timers.average(); // a std::duration
timers[1].duration(); // a std::duration

Dependencies

• #4

Dependencies

• #6

This module unit includes all of its inner modules in its main .hpp file. Also, an additional .cfg.hpp should be responsible for all preprocessor verifications, if any.

All of this module's types (e.g. namespace-level typedefs, classes, enums, structs, unions) must be forward-declared in the module's .fwd.hpp header. Inner artifacts (e.g. module, component) are prohibited to forward-declare types anywhere else.

File structure

• $PROJECT_ROOT/
  • include/
    • adl/oct.hpp
    • adl/oct.fwd.hpp

A "traits"-like class with the implementations for all the operators. Accepts mark_timers.

This includes migrating all functions from adl::operators and adl::dsl namespaces into the adl::oct namespace.

E.g. template <VarType_, typename = common_var_t<VarType_>> void function(VarType_) into void function(oct_var), void function(octdiff_var), ...

Dependencies

• #18
• #13
• #14

Dependencies

• #7
• #19

Dependencies

• #13

Dependencies

• #6

C++17's basic_string_view compatibility layer.

Dependencies

• #5

Dependencies

• #24

Checklist

• adl/oct/system/oct_system_stats
• adl/oct/system/octdiff_system_stats

A flat, non-coherent, difference-bound matrix. Accesses to elements are done in terms of octdiff_vexpr objects (or any other type that may be converted to it).

Dependencies

• #33
• #31
• #36

Dependencies

• #6

Dependencies

• #7
• #13
• #14

Just like the matrix described in #34, except that coherence is built-in. Follows Miné's description of a half-matrix in his thesis.

Dependencies

• #33
• #31
• #36

Dependencies

• #24
• #22
• #23

C++17's std::char_traits compatibility layer.

Dependencies

• #5

This module unit includes all of its inner modules in its main .hpp file. Also, an additional .cfg.hpp should be responsible for all preprocessor verifications, if any.

This module implements an octagonal domain-exclusive DSL. This DSL includes user-literals and operators that can be used by the user to define constraints, systems and problems in the octagonal domain. Each of the parent's class that participates in the DSL should have a specific include header file.

Because the DSL does not declare types (as of now), there will be no .fwd.hpp header file.

File structure

• $PROJECT_ROOT/
  • include/adl/oct
    • dsl.hpp

Guidelines for implementations:

• Is it a template class/struct specialization? Use adl_*CLASS
• Is it a non-template class/struct? Use adl_*CLASS
• Is it a non-constexpr non-type-member (global or namespace) function declaration? Use adl_*API
• Is the full path to a non-constexpr function definition non-templated or specialized? Use adl_IMPL
• Does the full path to a non-constexpr function definition contain any non-specialized template parameter? Use inline.

Examples for template types:

// Declaration
template<typename T> struct my_type;

// Definition
template<typename T> struct my_type {
    void function();
    template <typename F> void tpl_function(F);
    void inline_function() {}
};

// Member function definition
template <typename T>
inline void my_type<T>::function() {}

// Template member function definition
template <typename T>
template <typename F>
inline void my_type<T>::tpl_function(F) {}

// Specialization declaration (if any)
template<> struct adl_CLASS my_type<int> {
    void function();
    template <typename F> void tpl_function(F);
    void inline_function() {}
};

// Specialization: Member function definition
template <>
adl_IMPL void my_type<int>::function() {}

// Specialization: Template member function definition
template <>
template <typename F>
inline void my_type<int>::tpl_function(F) {}

// Specialization: Template member function specialized definition
template <>
template <>
adl_IMPL void my_type<int>::tpl_function<int>(F) {}

Examples for non-template types:

// Declaration
struct my_type;

// Definition
struct my_type {
    void function();
    template <typename F> void tpl_function(F);
    void inline_function() {}
};

// Specialization: Member function definition
adl_IMPL void my_type::function() {}

// Specialization: Template member function definition
inline void my_type::tpl_function(F) {}

Examples for functions:

// Declaration
adl_API void function();

template <typename F> void tpl_function(F);
template <> adl_API void tpl_function<int>(F);

adl_API void inline_function() {}


// Definition
adl_IMPL void function() {}

template <typename F> 
inline void tpl_function(F) {}

template <> adl_IMPL void tpl_function<int>(F) {}

The rest follows standard convention (constexpr at declaration and definition, etc).

Dependencies

• #21
• #19

This module contains the CPU implementation of a DBM and all of the operators for the octagon domain.

Dependencies

• #6

Dependencies

• #12
• #17

Dependencies

• #5