Dimensional Data

In C++ 17, there is a very useful alias template for metaprogramming that can be used to simplify use of SFINAE. The void_t is a meta-function that is used to map any types ( or types) to type void. In this post, we explain what is void_t, how you can use it in different examples. What is alias template void_t in C++ 17? The void_t is an alias template which is introduced with C++17, it is defined in header and it is a metafunction that is used to map any types (or a sequence of any types) to type void. The main purpose of void_t is to make easy writing of type traits. It is used to solve SFINAE (Substitution Failure Is Not An Error) prior to concepts of C++20 standard. SFINAE rule says that If the deduced type or explicitly specified type for the template parameter fails, the specialization is discarded from the overload set instead of causing an error in compilation. Since C++17, the std::void_t is defined as below.   template using void_t = void;   Now, let’s see how we can use it in template definitions. How to use alias template void_t to check a typename in a template? We can use void_t to if a class has a certain typename using at compile time, here we check if it has ‘type’ typename.   template struct hastype : std::false_type {};   template struct hastype : std::true_type {};   here is a full example about this, here we check ‘typeB‘ typename if it has or not. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28   #include #include   struct stA { typedef int typeA; };   struct stB { typedef int typeB; }; template struct hastype : std::false_type {};   template struct hastype : std::true_type {};   int main() { std::cout

There is a new library feature in the C++17 standard, it is std::invoke which is a useful feature to uniformly invoke callable entities. In this post, we explain what std::invoke is and how we can use it in examples. First, let’s remind ourselves about what is a callable object and what is a functor in modern C++. What is callable object and what is functor in modern C++? A callable object (some call it a functor) is an object that can be used as a function or function pointer by using the operator(). This term is not the same as a function term in programming. We can pass many arguments with them; thus, we don’t need to define many global variables, we can use these kinds of variables in the scope that we use. Here you can find more details about it. What is std::invoke in C++ 17? The std::invoke call is a library feature in C++ 17 that allows invoking a method at run time and improved in C++20 and C++23 with invoke_r. It is defined in the  header and useful to write libraries with the same behavior as the standard’s magic INVOKE rule. You can use std::invoke to call a function or method, a lambda expression, or a member function, or can be used to access a data member, or you can use to invoke a function object. In C++17 it is defined as below,   template std::invoke_result_t     invoke( F&& f, Args&&… args ) noexcept();   In C++20 it is defined as below,   template constexpr std::invoke_result_t     invoke( F&& f, Args&&… args ) noexcept();   And since C++23, there is invoke_r and it is defined as below,   template constexpr R invoke_r( F&& f, Args&&… args ) noexcept();   How can we use std::invoke with a parametric function in C++17? Here is a simple std::invoke example with a parametric function. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18   #include   int myf(int x, int y) { return x*x+y*y; }   int main() { int z = std::invoke(myf, 1, 2);   std::cout

Solving C++ optimization problems are one of the areas of all quantitative disciplines from social science, economics to engineering fields such as computer science. Genetic Algorithm (GA) is a kind of machine learning process that is used to generate high-quality solutions to optimization and search problems by relying on biologically inspired operators such as mutation, crossover, and selection. In this post, we explain how you can achieve optimization using artificial intelligence techniques. The Genetic Algorithm that we use here below was first mentioned by Željko Kovačević (Embarcadero MVP). Željko has amazing VCL Examples and blog posts about C++ Builder. He gave me this example below as a console app about GA and allowed me to release it free, but credits of this code may require contact with him. Then I improve and simplify (I can’t ofc) it for the C++ Builder and C++ Builder CE. Here, the field and codes below may be harder for beginners but I am sure this post may help how you can develop your scientific applications with C++ Builder CE. What is a Genetic Algorithm? In computer science and research, a Genetic Algorithm (GA) is an algorithm that is used to solve optimization problems by evolving towards better solutions, just as sentient beings do in nature. Genetic Algorithm (GA) is a metaheuristic inspired by the process of natural selection that belongs to the larger class of evolutionary algorithms. Genetic algorithms are commonly used to generate high-quality solutions to optimization and search problems by relying on biologically inspired operators such as mutation, crossover, and selection. In a Genetic Algorithm, first, we create an initial population, then we iterate in a loop by calculating the fitness value, selection, crossover, and mutation steps as below, Genetic Algorithm Schema Genetic Algorithms are one of the older AI/ML methods developed to solve some problems such as solving sudoku puzzles. Genetic Algorithms and Fuzzy Logic were very popular in the 1990s. A typical genetic algorithm requires: A genetic representation of the solution domain, a fitness function to evaluate the solution domain. How to develop a genetic algorithm with C++ Builder? In our optimization example in C++, we develop an optimization algorithm such as Genetic Algorithm about our chosen field. Now let’s explain quickly what we mean by that. First, we have a global Input value that represents a value (number) for which Genetic Algorithm (GA) is trying to find its binary representation.   unsigned int inputValue = 1234567890;   We have individuals to evaluate with genetic algorithms, so we can create this class below. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22   class Individual { public: std::vector gene = std::vector(32); // number of bits unsigned int fitness{ std::numeric_limits::max() };   void evaluate() { unsigned int number = toNumber(); if (number

Containers are data storage arrays in modern C++ and they are very useful to iterate and search data with their amazing methods and properties. The C++ Standard Library defines four different main container types and one of them is associative containers such as std::map, and std::set. These class types allow us to use the look-up method “find()” by a value based on a value of that type. C++14 introduced the “Heterogeneous Lookup In Associative Containers” feature that allows the lookup to be done via an arbitrary type, so long as the comparison operator can compare that type with the actual key type. In this post, we explain containers, associative containers, and heterogeneous lookup in associative containers. What is a container in C++? Containers are data storage arrays in modern C++, and they are very useful to iterate and search data with their amazing methods and properties. In C++, there are four main types of containers: Sequence Containers (vectors, arrays, …) Associative Containers (maps, sets, …) Unordered Associative Containers (unordered_set, unordered_map, …) Container Adapters (stack, queue, priority_queue) If you want to know more about containers, here are more details about their types: What are associative containers in C++? Associative Containers are class templates of container types that can be used to implement sorted data structures where can be quickly searched. They are sorted by keys. We can say they are about O(log n) complexity data structures. The associative containers are: std::map : a class template for the collection of key-value pairs, its keys are unique and it is sorted by keys std::set : a class template for the collection of unique keys, it is sorted by keys  multiset : a class template for the collection of keys, it is sorted by keys multimap : a class template for the collection of key-value pairs, it is sorted by keys  What is heterogeneous lookup in associative containers in C++? The C++ Standard Library defines 4 associative container types. These class types allow us to use the look-up method find() by a value based on a value of that type. C++14 introduced the “Heterogeneous Lookup In Associative Containers” feature that allows the lookup to be done by an arbitrary type, so the comparison operator can compare types with the actual key type. The heterogeneous lookup in associative containers gives us to use std::map, std::set, and other associative containers. In example, let’s have some strings and have some values in a std::map (which is a associative container),   std::map mymap { { “Hello Developers”, 10 }, { “Please Visit Us”, 20 }, { “LearnCPlusPlus.org”, 30 } };   we can use find method of map as shown below:   auto m = mymap.find(std::string(“LearnCPlusPlus.org”)); // m iterator   In the heterogeneous lookup we can use less or other features. Is there a full example about heterogeneous lookup in associative containers in C++? When we want to do heterogeneous lookup, all we have to do is to use std::less or other heterogeneous lookup features and we should implement correct comparison methods. Here is an example,   std::map mymap2 { { “Hello Developers”, 10 }, { “Please Visit Us”, 20 }, { “LearnCPlusPlus.org”, 30 } };   The interesting thing is, it is straightforward to enable and we can use find method like so:   auto m = mymap2.find(std::string(“LearnCPlusPlus.org”)); // m iterator   Note that here m […]

Modern C++ has base class features that can be used with other modern features of C++. The std::integral_constant is the base class for the C++ type traits in C++11, and in C++14, std::integral_constant gained an operator () overload to return the constant value. In this post, we explain what integral_constant and () operator are in C++14. What is integral_constant in C++? The std::integral_constant  is the base class for the C++ type traits in header that wraps a static constant of specified type. The behavior in a code part that adds specializations for std::integral_constant is undefined. Here is the definition in header since C++11,   template struct integral_constant;   Here is a very simple example to how can we use std::integral_constant, in C++11 we can use ::value to retrieve its value,   typedef std::integral_constant five;   std::cout

C++11 introduced new forms of literals using modified syntax and semantics to provide User-Defined Literals (UDL) also known as Extensible Literals. While there was the ability to use them the standard library did not use any of them. In C++14, the commission added some standard literals. In this post, we explain user-defined literals operators and we explain some of these standard literals added in C++14. What are the user defined literal operators in C++? C++11 introduced new forms of literals using modified syntax and semantics in order to provide User-Defined Literals (UDL) also known as Extensible Literals. Using user-defined literals, user-defined classes can provide new literal syntax and they can be used with the operator “” to combine values with conversion operators. Here below, we explain how to use user-defined literals in C++. What are the standard user-defined literals in C++14? In C++14, we have some standard user-defined literal operators that comes with standard library. These are literals for basic strings, for chrono types, and for complex number types. We can access to these operators by: using namespace std::literals; using namespace std::string_literals; using namespace std::literals::string_literals; C++14 adds the following standard literals below, For the string types there is an operator”” s() for basic string, s : std::basic_string types for creating the various string types std::string, std::wstring, etc. here how we can use it with auto,   auto str = “LearnCPlusPlus.org”s; // auto deduction to string   Suffixes for std::chrono::duration values, h : hour type for the std::chrono::duration time intervals m : minute type for the std::chrono::duration time intervals s : second type for the std::chrono::duration time intervals ms : millisecond type for the std::chrono::duration time intervals ns : nanosecond type for the std::chrono::duration time intervals us : u.second type for the std::chrono::duration time intervals here how we can use them with auto,   auto durh = 24h;            // auto deduction to chrono::hours auto durm = 60min;            // auto deduction to chrono::minutes auto durs = 120s;            // auto deduction to chrono::seconds auto durms = 1000ms;         // auto deduction to chrono::milliseconds auto durns = 2000ns;         // auto deduction to chrono::nanoseconds   Suffixes for complex number literals, if : imaginary number for the std::complex types i : imaginary number for the std::complex types il : imaginary number for the std::complex types here how we can use them with auto,   auto zi   = 5i;             // auto deduction to complex auto zif  = 7if;             // auto deduction to complex auto zil  = 9il;             // auto deduction to complex   there are more definitions. Is there a full example of how to use standard user-defined literals in C++14? Here is a full example about standard user-defined literals in C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27   #include #include #include #include #include   using namespace std::literals; using namespace std::string_literals; // using namespace std::literals::string_literals;   int main() { auto str = “LearnCPlusPlus.org”s; // auto deduction to string   auto durh = 24h;            // auto deduction to chrono::hours auto durm = 60min;            // auto deduction to chrono::minutes auto durs = 120s;            // auto deduction to chrono::seconds auto durms = 1000ms;         // auto deduction to chrono::milliseconds auto durns = 2000ns;         // auto deduction to chrono::nanoseconds   auto zi   = 5i;             // auto deduction to complex auto zif  = 7if;             // auto deduction to complex auto zil  = 9il;             // auto deduction to complex   }   For more information about the standard user-defined literals, please […]

The tuple ( std::tuple ) is a class template that stores the different types of elements, it also supports empty lists in modern C++. This template was introduced in C++11 and improved in C++14. In this post, we explain tuple addressing via type features that come with the C++14 standard. What is std::tuple in C++? The tuple ( std::tuple) is a class template a fixed-size collection of different types of values like floats, integers, texts, etc. and it is defined in the tuple header. In another term tuple stores the different types of elements, it also supports empty lists. This template has been available since C++11 and improved in C++14, and C++20 standards. In C++ programming, the std::tuple is a generalization of std::pair. The destructor of the tuple is trivial if std::is_trivially_destructible::value is set to true for every type in Types. What is the syntax for std::tuple in C++? Here is the syntax of std::tuple in C++,   template class tuple;   Is there a C++ std::tuple example, how can we use tuples? Here is a example to define different types of members in a my_tuple,   std::tuple my_tuple { “text one”, 9, 2.22, “text two”, 15 , 7.88, “text three”};   std::cout