Dimensional Data

With the C++17 standard, the contents of the Parallelism Technical Specification are added to modern C++, and as a result, make their way into many C++ compilers and IDEs, such as the latest C++ Builder 12. This feature adds new overloads, taking an additional execution policy argument, to many algorithms, as well as entirely new algorithms. Three execution policies are supported, which respectively provide sequential, parallel, and vectorized execution. What is parallel programming (parallelism, parallel computing) ? Parallel computing (Parallel Programming, Parallelism, Parallelization) is a type of computation that applies many calculations or processes simultaneously. Parallel Programming is generally used to solve heavy calculation problems such as real-time analysis of multi-dimensional data, image processing, calculations on fluid mechanics, thermodynamics, and other engineering problems. Parallel Programming is a method that uses multiple computational resources, processors, or processing by groups of servers. Generally, in this type of programming, it takes a problem, breaks it down into a series of smaller steps, delivers instructions, and processors execute the solutions of each part at the same time in different Threads, CPU Cores, CPUs, GPUs. There are many ways to use parallel programming methods and skills, here is an example, What is the development history of parallelism in C++? We can classify the parallel computation level by the level of the hardware technology that supports parallel computation technologies. This depends on your CPU, GPU, Hardware (board, rams, chipsets, …) and Networking technologies (Connection protocols, fibers, WiFi, 5G, etc.) . In other words, this is mostly depends to the distance between computational nodes and its architecture. In the early ages of computers, and computation, some high-processing computer (such as Cray computers) became famous for their vector-processing computers in the 1970s and 1980s. However, vector processors—both as CPUs and as full computer systems—have generally disappeared. Today, we have modern processor instruction sets that have modern vector processing instructions. In addition to these Vector processor examples, we have many Parallelism examples, such as; Multi-core computing, Symmetric multiprocessing, Distributed computing, Cluster computing, Massively parallel computing, Grid computing, Cloud computing, Specialized parallel computers, Reconfigurable computing with field-programmable gate arrays, General-purpose computing on graphics processing units (GPGPU), Application-specific integrated circuits. In 2012, by the improvements in GPUs, representatives from NVIDIA, Microsoft and Intel, independently proposed library approaches to parallel computing in the C++ Standard Library. The authors of these proposals submitted a design in a joint proposal to parallelize the existing standard algorithms library. This proposal was refined under the name of the “Parallelism Technical Specification” over two years. During this process, the Parallelism Technical Specification community, added a lot of feedback from their experimental implementations, since the final version which was published in 2015. As a result, the C++ Standardization Committee had spend three years of experience with the Technical Specification’s design, then all these Parallelism Technical Specifications are added to the C++17 standard, and they are improved in C++20, and still being improved in C++23. (source: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0024r2.html). Parallelism is very important part of programming, because your algorithm can speed up 100-200 times or more (depends of number of CPU cores or GPU cores/transistors). This is why it needs to be improved in every new standard. What is the std::sort algorithm parallelism feature in C++? One of the great examples of parallelism is the std::sort algorithm in modern C++. The Standard Template Library or STL has many algorithms for operations like searching, counting, […]

In modern C++, the filesystem library allows portable interaction with directories and directory-like structures providing functions such as listing directory contents and moving files. After the C++17 standard, the contents of the Filesystems Technical Specification are now part of modern C++ and are implemented in the filesystem library. What Is the filesystems library in C++ 17? The Filesystem Library is defined in the  header (as a std::filesystem namespace), it provides operations on file systems and their components, such as paths, regular files, and directories. This library allows portable interaction with directories and directory-like structures by using classes and non-member functions. It is modernized well for C++, it is largely modeled on POSIX, and flexible enough to be implementable for different operating systems. After the C++17 standard, the contents of the Filesystems Technical Specification are now part of modern C++ and are implemented in the filesystem library. The filesystem library was previously being used by the boost.filesystem which was published in 2015. In C++17, they merged this library into modern C++. Note that, the boost implementation libraries are still available on more compilers and platforms for many benefits. The filesystem library consists of a lot of file operations (copy, move, permissions), directory operations (listing, iterating, …), and path operations. Some of classes are path, directory_entry, directory_iterator, perms, file_status, … and some of non-member functions in this library are copy, copy_file, current_path, exists, file_size, rename, remove, status, is_directory, is_empty, … Are there some examples of how to use the filesystems library in C++? Here are some examples that can be used with C++17 and standards beyond it, How can I use std::filesystem::current_path in C++ 17? In C++17, we can use std::filesystem::current_path to get current path on runtime. Here is a simple filesystem example in modern C++ that you can get current path.   #include #include   int main() {   std::cout

In programming, one of the most used variable types are text strings, and they are sometimes really important when storing and retrieving valuable data. It is important to store your data safely in its language and localization. Most programming languages have issues when storing texts and letters. In C++, there is very old well-known string type (arrays of chars) and modern types of std::basic_string types such as std::string, and std::wstring. In addition to these modern string types, C++ Builder has another amazing string feature, UnicodeString. In this post, we explain what a basic string and UnicodeString are in modern C++ and how to use them. What are the string types in C++? In general there are 3 type of alphanumeric string declarations in C++; Array of chars (See Fundamental Types)chars are shaped in ASCII forms which means each character has 1 byte (8 bits) size (that means you have 0 to 255 characters) Basic String (std::basic_string)The basic_string (std::basic_string and std::pmr::basic_string) is a class template that stores and manipulates sequences of alpha numeric string objects (char, w_char,…). A basic string can be used to define string, wstring, u8string, u16string and u32string data types. String or UnicodeStringThe UnicodeString string type is a default String type of RAD Studio, C++ Builder, Delphi that is in UTF-16 format that means characters in UTF-16 may be 2 or 4 bytes. In C++ Builder and Delphi; Char and PChar types are now WideChar and PWideChar, respectively. There is a good article about Unicode in RadStudio. In addition, there were some old string types that we used in C++ Builder and Delphi before, AnsiStringPreviously, String was an alias for AnsiString. For RAD Studio, C++ Builder and Delphi, the format of AnsiString has changed. CodePage and ElemSize fields have been added. This makes the format for AnsiString identical for the new UnicodeString. WideStringWideStrings were previously used for Unicode character data. Its format is essentially the same as the Windows BSTR. WideString is still appropriate for use in COM applications. What is basic_string? The basic_string (std::basic_string and std::pmr::basic_string) is a class template that stores and manipulates sequences of alpha numeric string objects (char, w_char,…). For example, str::string and std::wstring are the data types defined by the std::basic_string. In other words, basic_string is used to define different data_types which means a basic_string is not a string only, it is a namespace for a general string format. A basic string can be used to define string, wstring, u8string, u16string and u32string data types. The basic_string class is dependent neither on the character type nor on the nature of operations on that type. The definitions of the operations are supplied via the Traits template parameter (i.e. a specialization of std::char_traits) or a compatible traits class. The basic_string  stores the elements contiguously. Several string types for common character types are provided by basic string definitions as below. String Type Basic String Definition Standard std::string std::basic_string std::wstring std::basic_string std::u8string std::basic_string (C++20) std::u16string std::basic_string (C++11) std::u32string std::basic_string (C++11) Several string type in std::pmr namespace for common character types are provided by the basic string definitions too. Here are more details about basic string types and their literals. Note that you can use both std::basic_string (std::string, std::wstring, std::u16string, …) and UnicodeString in C++ Builder. Here are more details about basic string types and their literals. What is UnicodeString (String) in C++ Builder? The Unicode standard for UnicodeString provides a unique number for every character (8, 16 or 32 bits) more […]

The math library  in C language is designed to be used in mathematical operations. From the first C language to the latest C++ Builder 12, there have been many changes and improvements in both hardware and software. We were able to use this math.h library in C++ applications. After the C++17 standard, this library is modernized in the cmath library, Functions are declared in  header for compatibility reasons in modern C++. In this post, we explain what are the math.h and cmath libraries. What is the math.h math library in C++? In the early days of computers there was an FPU (Floating Point Unit) in addition to a CPU (Central Processing Unit). While the CPUs were slower in floating point operations (especially in trigonometric functions) FPUs were faster than CPUs in those days. The math library  in the C language is designed to be used in mathematical operations with these FPUs and CPUs. From the first C language to the latest CLANG C++ compiler, there have been many changes and improvements in both hardware and software. We were able to use this math.h library in C++ applications. The math library library functions are declared in math.h header file and it is in the standard library of the C programming language. Most of the functions are trigonometric and basic math functions, and they mostly use floating point numbers such as float, double, or long double variables. Trigonometric functions use radians in angular parameters and all functions take doubles for floating-point arguments unless otherwise specified. In C++ (C++98, C++11, C++14), these C functions were begin used by the same header . For example, if you want to use sin(), cos(), tan(), exp(), log(), and pow() functions you have to add library to the C and C++11, C++14 applications. Note that, some mathematical library functions that operate on integers are instead specified in the  header, such as abs, labs, div, and ldiv. Here is a simple C example using the sin function.   #include #include   int main() { double x = sin(1.0); }   What is the cmath mathematical special functions library in C++? In C++11 and C++14, we were able to use the math.h library in C++ applications. After the C++17 standard, this library is modernized in the cmath library, and functions are declared in  header for compatibility reasons in modern C++, and the is an optional old header to support some old codes. The CMath Mathematical Special Functions Header  defines mathematical functions and symbols in the std namespace, and previous math functions are also included, it may also define them in the global namespace. You have to add a std namespace with using namespace std; or you should use the std:: prefix for each math function. Some of the mathematical special functions are added to the C++17 cmath library header by the contents of the former international standard ISO/IEC 29124:2010 and math.h functions added too. These are only available in namespace std. If you do not use namespace you should add std:: prefix to use these modern math functions. Here is a simple C++ example using the sin function.   #include #include   int main() { double x = std::sin(1.0); }   What is the difference between math.h and cmath in modern C++? The CMath Mathematical Special Functions Header  defines mathematical functions and symbols in the std namespace, and previous math functions are also […]

In C++11 and C++14, we were able to use this math.h library in C++ applications. After the C++17 standard, this library modernized math operations with the cmath library. Functions are declared in  header. For compatibility reasons the is an optional alternative to support older code. In this post, we list most of these mathematical functions declared in the header of modern C++. What is cmath mathematical functions library in C++? The CMath Mathematical Special Functions Header  defines mathematical functions and symbols in the std namespace. It includes the previous math functions. It may also define them in the global namespace. You have to add a std namespace using namespace std; or you should use the std:: prefix for each math function. Some of the mathematical special functions are added to the C++17 cmath library header by the contents of the former international standard ISO/IEC 29124:2010 and math.h functions added too. These are only available in namespace std. If you do not use namespace you should add std:: prefix to use these modern math functions. In general, they are mostly double functions and can be slower, but they have more accurate results. For example sin() uses double variables, sinf() uses a float variable (same as C++11, faster, less accurate), while sinl() is used with long double variables (same as C++11, also slower, but more accurate). Here is a simple C++ example using the sin function.   #include #include   int main() { double d = std::sin(1.0); // double float  f = std::sinf(1.0); // float (C++11) long double  l = std::sinl(1.0); // long double (C++11)   }   What are the CMath mathematical special functions in modern C++ 17? There are many new modern mathematical special functions in the C++17 cmath header. Such as functions for associated Laguerre polynomials, elliptic integral of the first kind functions, Cylindrical Bessel functions (of the first kind), Cylindrical Neumann functions, Exponential integral functions, Hermite polynomials functions, Legendre polynomials functions, Laguerre polynomials, Riemann zeta function, and some spherical functions. Here is a list of the CMath special functions. Description double float long double Associated Laguerre polynomials assoc_laguerre assoc_laguerref assoc_laguerrel Associated Legendre polynomials assoc_legendre assoc_legendref assoc_legendrel Beta function beta betaf betal Elliptic integral of the first kind (complete) comp_ellint_1 comp_ellint_1f comp_ellint_1l Elliptic integral of the second kind (complete) comp_ellint_2 comp_ellint_2f comp_ellint_1l Elliptic integral of the third kind (complete) comp_ellint_3 comp_ellint_3f comp_ellint_1l Regular modified cylindrical Bessel functions cyl_bessel_i cyl_bessel_if cyl_bessel_il Cylindrical Bessel functions (of the first kind) cyl_bessel_j cyl_bessel_jf cyl_bessel_jl Irregular modified cylindrical Bessel functions cyl_bessel_k cyl_bessel_kf cyl_bessel_kl Cylindrical Neumann functions cyl_neumann cyl_neumannf cyl_neumannl Elliptic integral of the first kind (incomplete) ellint_1 ellint_1f ellint_1l Elliptic integral of the second kind (incomplete) ellint_2 ellint_2f ellint_2l Elliptic integral of the third kind (incomplete) ellint_3 ellint_3f ellint_3l Exponential integral expint expint expint Hermite polynomials hermite hermitef hermitel Legendre polynomials legendre legendref legendrel Laguerre polynomials laguerre laguerref laguerrel Riemann zeta function riemann_zeta riemann_zetaf riemann_zetal spherical associated Legendre functions sph_legendre sph_legendref sph_legendrel spherical Bessel functions (of the first kind) sph_bessel sph_besself sph_bessell spherical Neumann functions sph_neumann sph_neumannf sph_neumannl Note that, by the C++20 standard, only default names of math functions are used. For example, the laguerre() is used for the float, double and long double versions. For more details about changes in C++17 standard, please see this https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0226r1.pdf C++ Builder is the easiest and fastest C and C++ compiler […]

The features of C++17 were a big step in the history of C++ and brought a lot of new features. In C++17, there are new auto rules for direct-list-initialization. This feature in C++, changes the rules for auto deduction from a braced-init-list. In this post, we explain what these new rules for auto deduction with examples are. What is auto keyword in C++? The auto keyword arrives with the new features in C++11 and improved in C++17, can be used as a placeholder type specifier (an auto-typed variable), or it can be used in function declaration, or in a structured binding declaration. The auto keyword can be used with other new CLANG standards like C++14, C++17, etc. What are the new rules for auto deduction in C++ 17? In C++17, For copy-list-initialization, the auto deduction will either deduce a std::initializer_list (if the types of entries in the braced-init-list are all identical) or be ill-formed otherwise. Note that, auto a = {1, 2, 3}, b = {1}; remains unchanged and deduces initializer_list. This change is intended as a defect resolution against C++14. Now, let’s see the examples below. Auto deduction from braced-init-list Rule #1 For direct list-initialization: For a braced-init-list with only a single element, the auto deduction will deduce from that entry. In the example below, there is a single member in the braced-init-list, and this is automatically defined as an initializer_list that consists of int members.   auto a = { 30 }; // decltype(a) is std::initializer_list for (auto i : a)  std::cout

In modern programming sometimes we want to use a sequence of integers that are created at compile-time. In C++14, the std::integer_sequence is a class template for the sequence of integers that is generated at compile-time. In this post, we explain what integer sequence (std::integer_sequence) is in modern programming. What is the integer sequence (std::integer_sequence) in C++ 14? In C++14, the std::integer_sequence is a class template defined in a header that can be used for the sequence of integers generated at compile-time. In some cases, looping through a range of numbers whose span is unknown is used and, in these cases, we can use the std::integer_sequence integer sequence. Thus, we can create a sequence of integers at compile time. Our application knows the sequence of integers before it runs, and we use them on runtime as a package. In other words, the std::integer_sequence is used to hold a sequence of integers which can be turned into a parameter pack. We can use integer_sequence in template programming or meta-programming algorithms, and this will make our code faster and less complex. In C++14, a simple syntax for the std::integer_sequence can be written as shown below.   template class integer_sequence;   Here, T is the type of integers and val is a parameter pack of integers. Is there a simple integer sequence (std::integer_sequence) example in C++ 14? Here is a simple example how we can use std::integer_sequence.   template void print_sequence2(std::integer_sequence) { ( (std::cout

C++14 brought us a lot of useful things that we use today. One of the great features of C++14 was the member initializers and aggregates feature that a class with default member initializers may now be an aggregate. In this post, we explain how can use member initializers and aggregates with examples. What are the member initializers and aggregates features in C++14? With the new C++14, a class or struct with default member initializers may now be an aggregate in definition. “If there are fewer initializer-clauses in the list than there are members in the aggregate, then each member not explicitly initialized shall be initialized from its brace-or-equal-initializer or, if there is no brace-or-equal-initializer, from an empty initializer list“. Here is an example,   struct st_X { int a; int b = 100; }; st_X X = { 5 };   Here, X.b will be 100 automatically. Are there simple examples about member initializers and aggregates features in C++14? This feature can be good to be used with default values (i.e. “Unknown”), here is an example.   struct st_student { std::string name; int score; std::string uni = “Unknown”; };   st_student s0 = { “David Millington”}; st_student s1 = { “Yilmaz Yoru”, 98 }; st_student s2 = { “Ian Barker”, 99, “Harvard University” };   Here, David will have 0 score and “Unknown” university, Yilmaz will have “Unknown” university. We can use parameters in the next parameters.   struct st_test {  const char* str; int a; int val = str[a]; }; st_test test = { “ABCD”, 2 };   Here example above, value of test.val is initiated automatically to 67 which is third char ‘C’. Is there a full example about member initializers and aggregates feature in C++14? Here is a full example. 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 29 30 31 32 33 34 35   #include #include   struct st_student { std::string name; int score; std::string uni = “Unknown”; };   struct st_test {  const char* str; int a; int val = str[a]; };   struct st_X { int a; int b = 100; };   int main() { st_student s0 = { “David Millington”}; st_student s1 = { “Yilmaz Yoru”, 98 }; st_student s2 = { “Ian Barker”, 99, “Harvard University” };   std::cout

In C++14, there are pretty good new overloads of std::equal, std::mismatch, and std::is_permutation that can be used to take a pair of iterators for the second range. They can be used with the new C++ Builder 12 along with the 11.x, or 10.x versions too. In this post, we explain these new overloads that we use ranges of iterations. What are the new overloads for ranges in C++ 14? In C++14, there are new overloads of std::equal, std::mismatch, and std::is_permutation that can be used to take a pair of iterators for the second range. We can pass them in two full ranges that have a beginning and end. In modern C++, the range parameter is obtained from a std::list without the original list that needs to be traversed through to get the size. In C++11, std::equal, std::mismatch, and std::is_permutation had 3 parameters, these were First1, Last1 for the Range1 and First2 for the Range2. In C++ 14, there is one more parameter that you can use, it is the Last2 for the Range2. What is the new overload for the std::equal in C++14? In C++11, std::equal is defined as below.   template inline bool equal(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2)   The std::equal is defined in the header included in the header that returns true if the range between the First1 and Last1 is equal to the range between the First2 and the First2 + (Last1 – First1), and it returns false if this is not satisfied.   std::string s = “abCba”; std::cout

In C++11, the final specifier is used for a function or for a class that cannot be overridden by derived classes, and there was no way to check if that class or method is the final. In C++14, there is a std::is_final type trait that can be used to detect if a class or a method is marked as a final or not. In this post, we explain how we can use the std::is_final type trait in C++14 and C++17. What is the final specifier in modern C++? The final specifier (keyword) is used for a function or for a class that cannot be overridden by derived classes. Regarding virtual overrides, C++11 tends to tighten the rules, to detect some problems that often arise. To achieve this goal C++11 introduced a new contextual keyword, the final specifier. The final keyword specifies that a method cannot be overridden, or a class cannot be derived. If you want to learn more about it, here it is, What is the std::is_final type trait in C++ 14? The std::is_final type trait (UnaryTypeTrait) defined in detects if a class is marked final and returns true or false boolean. If a class or method is final, it returns the member constant value equal to true, if not returns the value is false. Here is the syntax (since C++14).   template struct is_final   How can we use the std::is_final type trait in C++ 14? We can use the std::is_final type trait to check classes if it is marked as a final or not. Here is a simple example.   class myclass final { };   if(  std::is_final::value ) std::cout