Solarian Programmer

Install Python with NumPy SciPy Matplotlib on macOS Big Sur (Apple Silicon arm64 version)

2021-06-15 23:59:36 +0000

In this article, I will show you how to install Python with NumPy, SciPy and Matplotlib on macOS Big Sur. I will show you how to install natively the above three libraries, using arm64 Apple Silicon versions. I assume that you have one of the M1 or newer arm64 processors. If you have an Intel based Mac, please check my other article.

MacOS Big Sur comes by default with Python 2.7 which, at this point, receives only bug fixes and is EOL since 2020. Python 3 is the future and it is supported by all major Python libraries. In this tutorial, we’ll use Python 3.9 which is the latest stable release of Python at the time of this writing.

Start by installing the Command Line Tools for macOS. Please note, that you will need the Command Line Tools even if you’ve already installed Xcode. Open a Terminal and write:

1 xcode-select --install

As a side note, after you install the Command Line Tools, you will also get a slightly older Python 3 version (3.8). At the time of this writing, neither the official version of Python from https://www.python.org/ or the Apple provided one will let you install natively NumPy, SciPy or Matplotlib using the default Python mechanism through pip.

In order to be able to install natively the above three libraries we are going to use Miniforge which is also recommended by Apple for other arm64 libraries that are not yet supported through pip.

On the Miniforge page, make sure to download the arm64 (Apple Silicon) architecture:

you should end up with a file named Miniforge3-MacOSX-arm64.sh in your Downloads folder.

Next, open a Terminal, navigate to your Downloads folder, make Miniforge3-MacOSX-arm64.sh executable and run the script:

1 cd Downloads
2 chmod +x Miniforge3-MacOSX-arm64.sh
3 ./Miniforge3-MacOSX-arm64.sh

You can safely accept the defaults and answer yes to all questions. Once the installation is finished activate Miniforge:

1 source ~/miniforge3/bin/activate

At this point, your prompt should indicate that you are using the base environment. If you open a new tab in Terminal or if you restart the Terminal the base environment will be activated by default.

Now, we are going to use the conda command from Miniforge to create a new environment, named work (feel free to use a different name), and activate it:

1 conda create -n work python=3.9
2 conda activate work

At this point, your prompt should indicate that you are using the work environment.

Once the work environment is activated we can install NumPy, SciPy or Matplotlib to this environment:

1 conda install numpy scipy matplotlib

Please note that if you restart your Terminal it will revert to the base environment. If you need to use the work environment or the libraries you just installed use:

1 conda activate work

to activate it.

As a side note, when you are in an active environment you can use the python command to invoke the Python interpreter, no need to use the version number.

Fire up Python, import scipy and print the version of the installed library. This is what I see on my machine:

1 (work) % python
2 Python 3.9.4 | packaged by conda-forge | (default, May 10 2021, 22:10:52)
3 [Clang 11.1.0 ] on darwin
4 Type "help", "copyright", "credits" or "license" for more information.
5 >>> import scipy as sp
6 >>> sp.version.version
7 '1.6.3'
8 >>> quit()(work) %

Let’s try something a bit more interesting now, let’s plot a simple function with Matplotlib. Start the python interpreter and try the next examples.

First, we’ll import NumPy and Matplotlib with:

1 import numpy as np
2 import matplotlib.pylab as plt

Next, we can define some points on the (0, 1) interval with:

1 t = np.linspace(0, 1, 100)

Now, let’s plot a parabola defined on the above interval:

1 plt.plot(t, t**2)
2 plt.show()

You should see something like this:

As you’ve probably noticed, plt.show() is a blocking command. You won’t be able to use the interpreter until you close Figure 1.

There is also an interactive mode in which you can plot functions. Close Figure 1 and write:

1 plt.ion()
2 plt.plot(t, t**2)
3 plt.title("Interactive plot test")
4 plt.plot(t, t**3)
5 plt.xlabel("t")

This is what you should see:

At any point you can disable the interactive plot mode with:

1 plt.ioff()

after which you will need to use the plt.show() function in order to actually see the result of the plt.plot function.

Getting Started with Clang and Visual Studio Code on Windows with MSYS2 and MinGW-w64

2021-06-11 00:20:53 +0000

This is a short introduction in getting started with Clang on Windows 10 under MSYS2 and MinGW-w64. The Clang and LLVM binaries from https://llvm.org/ require that you to have Visual Studio 2019 installed on your machine, MSYS2 is a lighter alternative. In the last part of this article, I will show you how to use VS Code to build and debug a simple C++ program.

This article is split into three parts:

Install MSYS2, Clang and GDB:

Start by installing MSYS2 from https://www.msys2.org/, the installer will guide you through the required steps. Once the installation is finished, start an MSYS2 MSYS terminal from the Windows start menu:

Update the system with:

1 pacman -Syu

and accept the updates by writing Y.

Repeat the above command one more time to be sure that the system is fully updated.

Next, we are going to install Clang and GDB:

1 pacman -S --needed base-devel mingw-w64-ucrt-x86_64-clang mingw-w64-ucrt-x86_64-gdb

write Y when asked if you agree to install the required dependencies.

At this point, we are done with the installation. Close the MSYS2 MSYS terminal by writing:

1 exit

Compile and debug a simple C++ program from the MSYS2 terminal:

From the Windows start menu find MSYS2 MinGW UCRT 64-bit and start a new terminal:

Alternatively, you can open the same terminal from the disk C → msys64 → ucrt64.exe.

Check the version of the installed Clang with:

1 clang --version

This is what I see on my machine:

1 $ clang --version
2 clang version 12.0.0
3 Target: x86_64-w64-windows-gnu
4 Thread model: posix
5 InstalledDir: C:/msys64/ucrt64/bin

Create a folder named cpp_test and inside, a new file named test.cpp with this content:

 1 #include <iostream>
 2 #include <vector>
 3 
 4 int main() {
 5     std::cout << "Hello, World\n";
 6 
 7     std::vector<int> V{1, 2, 3, 4, 5};
 8     int a = 8;
 9 
10     for(auto &e : V) {
11         std::cout << e << ' ';
12     }
13     std::cout << '\n';
14 
15     std::cout << "a = " << a << '\n';
16 }

You can build the program with:

1 clang++ -std=c++20 -Wall -Wextra -pedantic -g test.cpp -o test.exe

This is what I see on my machine if I build and run the above program:

 1 UCRT64 ~/cpp_test
 2 $ clang++ -std=c++20 -Wall -Wextra -pedantic -g test.cpp -o test.exe
 3 
 4 UCRT64 ~/cpp_test
 5 $ ./test
 6 Hello, World
 7 1 2 3 4 5
 8 a = 8
 9 
10 UCRT64 ~/cpp_test
11 $

If you want to debug the code directly with GDB try this:

1 gdb test.exe

Add a break point to the start of main with:

1 b main

Run the program to the previously added breakpoint with:

1 r

Advance three lines with:

1 n 3

You can visualize the content of the variable a with:

1 p a

Or, if you want to see the content of the vector V:

1 p V

If you want to run to the end of the program write:

1 c

and exit from the debugger with:

1 q

This is what I see on my machine if I run the above commands:

 1 UCRT64 ~/cpp_test
 2 $ gdb test.exe
 3 GNU gdb (GDB) 10.2
 4 Copyright (C) 2021 Free Software Foundation, Inc.
 5 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
 6 This is free software: you are free to change and redistribute it.
 7 There is NO WARRANTY, to the extent permitted by law.
 8 Type "show copying" and "show warranty" for details.
 9 This GDB was configured as "x86_64-w64-mingw32".
10 Type "show configuration" for configuration details.
11 For bug reporting instructions, please see:
12 <https://www.gnu.org/software/gdb/bugs/>.
13 Find the GDB manual and other documentation resources online at:
14     <http://www.gnu.org/software/gdb/documentation/>.
15 
16 For help, type "help".
17 Type "apropos word" to search for commands related to "word"...
18 Reading symbols from test.exe...
19 (gdb) b main
20 Breakpoint 1 at 0x1400015ac: file test.cpp, line 5.
21 (gdb) r
22 Starting program: C:\msys64\home\X\cpp_test\test.exe
23 [New Thread 5188.0x1aa8]
24 [New Thread 5188.0x114c]
25 [New Thread 5188.0x5b8]
26 
27 Thread 1 hit Breakpoint 1, main () at test.cpp:5
28 5               std::cout << "Hello, World\n";
29 (gdb) n 3
30 10              for(auto &e : V) {
31 (gdb) p a
32 $1 = 8
33 (gdb) p V
34 $2 = std::vector of length 5, capacity 5 = {1, 2, 3, 4, 5}
35 (gdb) c
36 Continuing.
37 Hello, World
38 1 2 3 4 5
39 a = 8
40 [Thread 5188.0x114c exited with code 0]
41 [Thread 5188.0x5b8 exited with code 0]
42 [Thread 5188.0x1aa8 exited with code 0]
43 [Inferior 1 (process 5188) exited normally]
44 (gdb) q
45 
46 UCRT64 ~/cpp_test
47 $

Compile and debug a simple C++ program from VS Code:

In the last part of the article, I will show you how to build and debug the above simple C++ program from VS Code. Download VS Code and install it on your machine. You can accept the default options.

Next, make sure you have a MSYS2 MinGW UCRT 64-bit terminal open, see the previous section.

We are going to add VS Code to the MSYS2 path. This is important because it will let VS Code know about the compiler and debugger that are available from MSYS2. Without this step, VS Code will not know from were to get your compiler and debugger.

Open the file .bashrc from the Home folder, here is an example of doing that using the nano text editor:

1 cd ~
2 nano .bashrc

Scroll to the end of the file and write or paste the next line:

1 export PATH=$PATH:/C/Users/$USERNAME/AppData/Local/Programs/Microsoft\ VS\ Code/bin

Save the file by pressing CTRL+O, exit from nano by pressing CTRL+X.

Next, write this in the terminal to enable the above modification:

1 source .bashrc

Navigate to the folder where you saved the C++ program in the previous section and erase the existing executable:

1 cd cpp_test
2 rm test.exe

Start VS Code in this folder with:

1 code .

From the VS Code left panel, select the file test.cpp. If prompted to install the C/C++ extension accept it, otherwise press on the extensions button from VS Code and search for C++. You want to install C/C++ from Microsoft.

Once the extension is installed, press on the Run and Debug button. Press again on Run and Debug. Select C++(GDB/LLDB) when presented with a list of environments, next select g++.exe - Build and debug active file. This will create a new folder named .vscode in your project folder.

Select the Explorer button from VS Code to see the files that are in cpp_test. Click on .vscode, you should see two files in there launch.json and tasks.json.

Open tasks.json and find the command property:

1 "command": "C:\\msys64\\ucrt64\\bin\\g++.exe",

Change g++.exe to clang.exe. It should look like this:

1 "command": "C:\\msys64\\ucrt64\\bin\\clang++.exe",

Next, find the args array

1             "args": [
2                 "-g",
3                 "${file}",
4                 "-o",
5                 "${fileDirname}\\${fileBasenameNoExtension}.exe"
6             ],

Add a few extra options:

1             "args": [
2                 "-std=c++20",
3                 "-Wall",
4                 "-Wextra",
5                 "-g",
6                 "${file}",
7                 "-o",
8                 "${fileDirname}\\${fileBasenameNoExtension}.exe"
9             ],

This is the full content of my tasks.json:

 1 {
 2     "tasks": [
 3         {
 4             "type": "cppbuild",
 5             "label": "C/C++: g++.exe build active file",
 6             "command": "C:\\msys64\\ucrt64\\bin\\clang++.exe",
 7             "args": [
 8                 "-std=c++20",
 9                 "-Wall",
10                 "-Wextra",
11                 "-g",
12                 "${file}",
13                 "-o",
14                 "${fileDirname}\\${fileBasenameNoExtension}.exe"
15             ],
16             "options": {
17                 "cwd": "${fileDirname}"
18             },
19             "problemMatcher": [
20                 "$gcc"
21             ],
22             "group": {
23                 "kind": "build",
24                 "isDefault": true
25             },
26             "detail": "Task generated by Debugger."
27         }
28     ],
29     "version": "2.0.0"
30 }

Next, click on the first line of the main function to add a breakpoint (left of the line numbers). You should see a red dot:

Press the Run and Debug again. VS Code should compile your program, run and stop at the breakpoint. In the left panel you can see the local variables of the current function which are not initialized at this point. Step three times by pressing the curve arrow from the top middle of VS Code.

Now, you can see the content of the vector V, if you click on it.

This is what I see on my machine:

If you want to continue the program, you can press the left triangle from the above middle panel.

If you want to learn more about VS Code check the documentation or leave me a comment with a specific question.

Enable OpenSSH server on Windows 10

2020-10-27 19:19:36 +0000

In this article, I will show you how to enable the OpenSSH server on Windows 10 and how to connect through ssh to a Windows 10 machine.

By default, recent versions of Windows 10 have an OpenSSH client already installed, this means that you can use a Windows 10 machine to connect through ssh to other machines, typically Linux servers, that have an ssh server enabled. How about when you want to be able to connect through ssh to another Windows computer ?

Go to the Windows Start menu and select Settings, next go to Apps → Optional features → Add a feature, on this page, search for OpenSSH Server or scroll until you find it and check the left box. Press Install.

Once the installation has finished, you need to start the OpenSSH server in order to be able to connect to this machine. Open a PowerShell window as an Administrator: go to Start → Windows Power Shell and right click on the Windows Power Shell app select More and pick Run as administrator, answer Yes when asked if you want to let this app to make changes to your device.

At this point, you can temporarily enable the OpenSSH server by writing the next command in Windows Power Shell:

1 Start-Service -Name "sshd"

You can connect to your Windows machine with:

1 ssh user_name@your_ip_address

If you need to find your IP address, run this command in PowerShell:

1 Get-NetIPAddress

When you will stop or restart Windows, the OpenSSH server will be also stopped. If you need to reenable it, you can use the above command to start the service or, if you know that you want this to be on permanently, write the next two commands in a PowerShell administrator window:

1 Start-Service -Name "sshd"
2 Set-Service -Name "sshd" -StartupType Automatic

The above will ensure that after a restart the sshd service will be always on.

Using the Visual Studio Developer Command Prompt from the Windows Terminal

2020-10-25 10:16:37 +0000

In this article, I will show you how to use the Visual Studio command line compiler from the Windows Terminal. I will assume that you’ve already installed Visual Studio 2019 on your machine. In my case, I have installed the Community edition with the Desktop development with C++ workload. By default, the installer will create a few links for using the development tools from the classical Windows Command Prompt and we are going to copy some settings from this to the Windows Terminal. My second assumption is that you’ve also installed the Windows Terminal, if this is not the case just open Microsoft Store, search for Windows Terminal and install it.

If you’ve ever played with Windows Terminal you already know why it is nicer to use than the classical Command Prompt, a few examples: tabs, vertical and horizontal splits, a resizable window, zoom in and out, proper copy paste to and from the Terminal, background colors and a lot of other possible customizations.

From the Windows Start menu, find Visual Studio 2019 → x64 Native Tools Command Prompt for VS 2019 and right click on it, chose More and select Open file location. This will open a folder in Windows Explorer, typically this folder will contain a couple of links to cmd.exe customized for development usage. Find the one named x64 Native Tools Command Prompt for VS 2019, right click on it and select Properties. Select the Shortcut tab, if it is not already selected, and copy the content of Target in a new text file. As an example, this is what mine contains:

1 %comspec% /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"

We need to do some modifications to the above line in order to be able to use it: remove %compspec%, escape the double quotes and replace each backward slash from the path with two forward slashes. You should end up with something like this (if you have the Professional or Entreprise editions of Visual Studio change the line accordingly):

1 /k \"C://Program Files (x86)//Microsoft Visual Studio//2019//Community//VC//Auxiliary//Build//vcvars64.bat\"

Next, open the Windows Terminal settings, this is a JSON file that can be customized. You can access the Settings by clicking on the downward arrow from the Windows Terminal menu. The Settings file should contain a few predefined profiles. For our particular case, easiest approach is to duplicate the settings for cmd.exe profile, e.g. in my case:

1 {
2     // Make changes here to the cmd.exe profile.
3     "guid": "{0caa0dad-35be-5f56-a8ff-afceeeaa6101}",
4     "name": "Command Prompt",
5     "commandline": "cmd.exe",
6     "hidden": false
7 },

Duplicate (copy and paste) the equivalent of the above for your case in the settings.json file.

Please note the guid variable, this is a unique identifier for each profile and we need to generate one. From the Windows Start menu open a classical x64 Native Tools Command Prompt for VS 2019 and write:

1 guidgen

The above should start an app named Create GUID. Select option 4 Registry Format, press New GUID and than Copy, replace the guid value from the duplicated profile with the value that you just copied (hint you can paste the copied guid).

Optionally, change the name value from the Settings file to something more descriptive e.g.: x64 Native Tools Command Command Prompt for VS 2019

Next, let’s append to the end of the commandline the modified path to vcvars64 from above.

You should end up with something like this:

1 {
2     // Make changes here to the x64  Native Tools Command Command Prompt for VS 2019 profile.
3     "guid": "{FA148184-C8B3-465E-A67C-4542E087E3C6}",
4     "name": "x64 Native Tools Command Prompt for VS 2019",
5     "commandline": "cmd.exe /k \"C://Program Files (x86)//Microsoft Visual Studio//2019//Community//VC//Auxiliary//Build//vcvars64.bat\"",
6     "hidden": false
7 },

Optionally, you can start in a particular directory instead of the default one by setting the value of startingDirectory, e.g:

1     "startingDirectory": "C:/DEV"

Save the settings.json file and reopen Windows Terminal. If there was any syntax error in settings.json you should see some warning message in the Windows Terminal, otherwise it should start normally.

Let’s try our new profile - from the drop down menu of the Windows Terminal (down arrow) select your new custom entry e.g. x64 Native Tools Command Command Prompt for VS 2019 if you followed this tutorial. As an example, this is what I see on my machine if I open the x64 Native … profile and invoke the cl.exe compiler:

 1 **********************************************************************
 2 ** Visual Studio 2019 Developer Command Prompt v16.7.6
 3 ** Copyright (c) 2020 Microsoft Corporation
 4 **********************************************************************
 5 [vcvarsall.bat] Environment initialized for: 'x64'
 6 
 7 C:\>cl
 8 Microsoft (R) C/C++ Optimizing Compiler Version 19.27.29112 for x64
 9 Copyright (C) Microsoft Corporation.  All rights reserved.
10 
11 usage: cl [ option... ] filename... [ /link linkoption... ]
12 
13 C:\>

If you prefer PowerShell to the Command Prompt for command line development, the procedure is similar. Duplicate the existing PowerShell profile from the Windows Terminal settings and replace the guid with a new value. Next, replace the value of commandline with:

1 powershell.exe cmd.exe /k \\\"C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Auxiliary\\Build\\vcvars64.bat\\\" `& powershell

As an example, this is how it looks on my machine (you may need to adapt it a bit for your particular case):

1 {
2     // Make changes here to the x64 Native Tools PowerShell for VS 2019 profile.
3     "guid": "{444226FA-04DE-4EC4-B529-0C00EAD16A82}",
4     "name": "x64 Native Tools PowerShell for VS 2019",
5     "commandline": "powershell.exe cmd.exe /k \\\"C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Community\\VC\\Auxiliary\\Build\\vcvars64.bat\\\" `& powershell",
6     "startingDirectory": "C:/DEV",
7     "hidden": false
8 },

At this point, you can use the Visual Studio developer tools from Windows Terminal. If you need to learn more about how to configure Windows Terminal check the documentation. For more info about using the command line for development check the Microsoft documentation.

Getting started with C++ MathGL on Windows and Linux

2020-06-25 23:03:10 +0000

In this article, I will show you how to install and get started with the C++ interface of MathGL on Linux and Windows. MathGL is a high quality scientific graphics library.

In the first two parts of the article I will describe how to install the library and how to build a C++ MathGL example. In the third part of the article we’ll use MathGL to create a 2D function graphic and save it as an image file. As a second example, we’ll use the FLTK GUI library to show the same 2D function:

This article is split in three parts:

I recommend that you read the install part for your OS and the part that shows how to use MathGL to create some graphics.

Install MathGL on Windows:

On Windows, the recommended approach to install MathGL is to use the official MathGL binaries. From the above page, download the GPL or LGPL binaries for MinGW 64 bits. After you’ve finished downloading the archive, you can extract it with 7zip.

Next, we are going to install the MinGW 64 GCC toolchain that was used to build the library. At the current time, easiest approach is to download Code::Blocks version 20.03. Make sure to download the file named codeblocks-20.03mingw-setup.exe.

Start the Code::Blocks installer and accept the defaults. Once the installation is finished, Code::Blocks will detect the included GCC toolchain.

Next, you will need to manually copy the content of the MathGL archive to the location where Code::Blocks has installed GCC, this is usually C:\Program Files\CodeBlocks\MinGW.

Copy the content of the bin folder of MathGL to the the bin folder of MinGW. When asked if you want to overwrite some files with the same names, skip these files.

Copy the content of the lib folder of MathGL to the the lib folder of MinGW.

Open the include folder of MathGL and copy the include folder mgl2. Inside the MinGW folder, go to x86_64-w64-mingw32, open the include folder and paste the mgl2 folder in here.

Open Code::Blocks and create a new project, chose Console Application and C++. Chose a name for the project and a location.

Once the C++ console project is open, right click on the project name (in the left panel) and select Build options. Select Linker Settings and in the Other linker options panel add the desired libraries: -lmgl in this case. If you want to be able to use the FLTK GUI library, like you will see in our second example, you will need to add -lmgl -lmgl-fltk. Press OK.

In Code::Blocks, you can use the Build and Run button (the small wheel with a green triangle icon) to compile and execute a program.

Next, remove the default C++ generated code from main.cpp and go to MathGL usage part of this article for an example.

Install MathGL on Linux:

For Linux, I will exemplify the installation part on a Debian based system.

Let’s start by installing a C++ toolchain. Open a Terminal and write:

1 sudo apt install build-essential

Next, install MathGL with:

1 sudo apt install libmgl-dev

Assuming that you’ve saved your MathGL program in a file named mgl_ex1.cpp, this is how you can build it:

1 g++ mgl_ex1.cpp -o mgl_ex1 -lmgl

or, if you are using the FLTK GUI library:

1 g++ mgl_ex1.cpp -o mgl_ex1 -lmgl -lmgl-fltk

Once the program is compiled, you can run it as usual on Linux with:

1 ./mgl_ex1

Next, go to the MathGL usage part of this article for an example program.

C++ MathGL usage example:

Here is a small C++ MathGL program that will draw a wave curve and save the graphic in an image file named mgl_example.png:

 1 #include <mgl2\mgl.h>
 2 
 3 int main() {
 4     mglGraph gr;
 5     gr.Title("MathGL Demo");
 6     gr.SetOrigin(0, 0);
 7     gr.SetRanges(0, 10, -2.5, 2.5);
 8     gr.FPlot("sin(1.7*2*pi*x) + sin(1.9*2*pi*x)", "r-2");
 9     gr.Axis();
10     gr.Grid();
11     gr.WriteFrame("mgl_example.png");
12 }

The image will be saved where your program executable is located.

Next, we’ll draw the same curve, but this time using a FLTK window that will let you play with the graph: zoom, pan, rotate and other operations:

 1 #include <mgl2/fltk.h>
 2 
 3 int graph(mglGraph *gr) {
 4     gr->Title("MathGL Demo");
 5     gr->SetOrigin(0, 0);
 6     gr->SetRanges(0, 10, -2.5, 2.5);
 7     gr->FPlot("sin(1.7*2*pi*x) + sin(1.9*2*pi*x)", "r-4");
 8     gr->Axis();
 9     gr->Grid();
10     return 0;
11 }
12 
13 int main() {
14     mglFLTK gr(graph, "MathGL demo window title");
15     return gr.Run();
16 }

If you want to learn more about the capabilities of MathGL I recommend that you check their examples and the user manual.

Getting started with GSL - GNU Scientific Library on Windows, macOS and Linux

2020-01-26 06:36:31 +0000

In this article, I will show you how to install GSL - the GNU Scientific Library on Windows, macOS and Linux, and how to compile and run a simple GSL program. GSL is a C library for numerical computations. You can use GSL for example to solve a linear system of equations, to fit a curve to a set of points, for numerical integration, statistical calculations and so on. You can find a detailed description of GSL capabilities in the GSL reference manual.

This article is split in a few parts:

I recommend that you read the install part for your OS and the part that shows how to use GSL to solve a linear system of equations.

Install GSL on Windows:

For Windows, I recommend that you first install Visual Studio 2019. Make sure that you install the proper Visual Studio and not Visual Studio Code which is an entirely different product. Once the Visual Studio installer starts, check the Desktop development with C++ workload:

Next, install git for Windows from https://git-scm.com/. If you are not familiar with git, just accept the defaults suggested by the installer.

Finally, we are going to install vcpkg which is a C++ library manager that will let us install GSL. I will install vcpkg in a folder on my C drive, feel free to install it in a different location, just avoid paths with empty spaces. Open a PowerShell window (PowerShell is already installed on Windows, you can find it in the Start menu):

1 cd C:\
2 mkdir DEV
3 cd DEV

Next, we are going to use git to get the latest vcpkg version:

1 git clone https://github.com/microsoft/vcpkg.git

After the above command finishes, go to the vcpkg folder, bootstrap and integrate vcpkg:

1 cd vcpkg
2 .\bootstrap-vcpkg.bat
3 .\vcpkg integrate install

At this point, you can use the vcpkg command to install any of the available C++ libraries. You can find the complete list of available libraries in the ports folder from the vcpkg installation. Once you use vcpkg to install a library, it will be available in your Visual Studio C++ projects.

Let’s install GSL with vcpkg:

1 .\vcpkg install gsl gsl:x64-windows

The above command will build and install GSL for 32 and 64 bits Visual Studio projects.

Next time when you want to install a C++ library that is available in the vcpkg ports, remember to open a PowerShell window and navigate to the where you’ve installed vcpkg. vcpkg is not added to the system path, so you need to be in the vcpkg folder in order to be able to use it.

As a side note, a library installed with vcpkg is directly available in your msbuild projects (the ones created by default by Visual Studio). If you want to create a CMake project, you will need to add the include folders and libraries to the CMake project.

Now, that you have GSL installed, start Visual Studio and create a new C++ console project. You can remove the hello world C++ code that is generated by the compiler and write your C++ GSL program, see the GSL usage part of the article for an example.

Install GSL on macOS:

On macOS, I recommend that you install the Command Line Tools which will give you the Clang C++ compiler and also installs a bunch of useful utilities like make, git, vim and so on. Open a Terminal and write:

1 xcode-select --install

just follow the installer suggestions to get the Command Line Tools.

Once the Command Line Tools are installed, we need to install the Homebrew package manager which will let us install GSL:

1 /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

At this point, you should be able to use the brew command to install GSL and CMake:

1 brew install gsl cmake

Now, that you have GSL installed, open your preferred C++ editor (if you don’t have one, a good suggestion is Visual Studio Code) and write a C++ GSL program, see the GSL usage part of the article for an example.

Install GSL on Linux:

For Linux, I will exemplify the installation part on a Debian based system.

Let’s start by installing a C++ toolchain. Open a Terminal and write:

1 sudo apt install build-essential gdb cmake pkg-config

Next, install GSL with:

1 sudo apt install libgsl-dev

By default GSL will use a GSL built version of BLAS which is a library for basic vector and matrix operations. If you have access to a a highly tuned BLAS version, like the one provided with MKL, I suggest to use it. Alternatively, you can install libatlas, which is not as fast a MKL, but it is usually faster than the BLAS version that is include with GSL. You can install libatlas with:

1 sudo apt install libatlas-base-dev

Now, that you have GSL installed, open your preferred C++ editor (if don’t have one, a good suggestion is Visual Studio Code) and write a C++ GSL program, see the GSL usage part of the article for an example.

GSL usage example - solving a linear system of equations:

In this part of the article, I will show you how to use GSL to solve a linear system of equation:

\[A \cdot x = b\]

Let’s start by including the necessary header files and filling the above A matrix and b vector with some values. For simplicity, we are going to use some random hard coded values. I will leave it as an exercise for the reader to discover how to use GSL to fill A and b with random numbers:

 1 // File "gsl_test.cpp"
 2 #include <iostream>
 3 #include <gsl/gsl_linalg.h>
 4 
 5 int main() {
 6     double A_data[] = {
 7         0.57092943, 0.00313503, 0.88069151, 0.39626474,
 8         0.33336008, 0.01876333, 0.12228647, 0.40085702,
 9         0.55534451, 0.54090141, 0.85848041, 0.62154911,
10         0.64111484, 0.8892682 , 0.58922332, 0.32858322
11     };
12 
13     double b_data[] = {
14         1.5426693 , 0.74961678, 2.21431998, 2.14989419
15     };
16 
17     // ...
18 
19 }

Next, we are going to use GSL views to access the data from the above two arrays:

 1 // ...
 2 
 3 int main() {
 4     double A_data[] = {
 5         // ...
 6     };
 7 
 8     double b_data[] = {
 9         1.5426693 , 0.74961678, 2.21431998, 2.14989419
10     };
11 
12     // Access the above C arrays through GSL views
13     A = gsl_matrix_view_array(A_data, 4, 4);
14     b = gsl_vector_view_array(b_data, 4);
15 
16     // ...
17 
18 }

You can, optionally, print the vector and matrix values using gsl_vector_fprintf and gsl_matrix_fprintf, e.g.:

 1 // ...
 2 
 3 int main() {
 4 
 5     // ...
 6 
 7     // Access the above C arrays through GSL views
 8     A = gsl_matrix_view_array(A_data, 4, 4);
 9     b = gsl_vector_view_array(b_data, 4);
10 
11     // Print the values of A and b using GSL print functions
12     std::cout << "A = \n";
13     gsl_matrix_fprintf (stdout, &A.matrix, "%lf");
14 
15     std::cout << "\nb = \n";
16     gsl_vector_fprintf (stdout, &b.vector, "%lf");
17 
18     // ...
19 
20 }

Please note, that a matrix is printed in the order that is stored in memory, row by row.

In order to solve the above system with GSL we first need to decompose the matrix A into the LU form and pass the decomposed matrix to the GSL linear solver:

 1 // ...
 2 
 3 int main() {
 4 
 5     // ...
 6 
 7     // Print the values of A and b using GSL print functions
 8 
 9     // ...
10 
11     // Allocate memory for the solution vector x and the permutation perm:
12     gsl_vector *x = gsl_vector_alloc (4);
13     gsl_permutation *perm = gsl_permutation_alloc (4);
14 
15     // Decompose A into the LU form:
16     int signum;       // Sign of the permutation
17     gsl_linalg_LU_decomp (&A.matrix, perm, &signum);
18 
19     // Solve the linear system
20     gsl_linalg_LU_solve (&A.matrix, perm, &b.vector, x);
21 
22     // Print the solution
23     std::cout << "\nx = \n";
24     gsl_vector_fprintf (stdout, x, "%lf");
25 
26     // Release the memory previously allocated for x and perm
27     gsl_vector_free(x);
28     gsl_permutation_free(perm);
29 }

Please note that we allocate memory for the solution vector x and a permutation of the rows of the matrix A during the LU decomposition. Since GSL is a C library, we need to release the allocated memory manually when it is not needed. Another observation is that the original values of the matrix A are destroyed during the decomposition and replaced with the values of the decomposition.

Here is entire program:

 1 #include <iostream>
 2 #include <gsl/gsl_linalg.h>
 3 
 4 int main() {
 5     double A_data[] = {
 6         0.57092943, 0.00313503, 0.88069151, 0.39626474,
 7         0.33336008, 0.01876333, 0.12228647, 0.40085702,
 8         0.55534451, 0.54090141, 0.85848041, 0.62154911,
 9         0.64111484, 0.8892682 , 0.58922332, 0.32858322
10     };
11 
12     double b_data[] = {
13         1.5426693 , 0.74961678, 2.21431998, 2.14989419
14     };
15 
16     // Access the above C arrays through GSL views
17     gsl_matrix_view A = gsl_matrix_view_array(A_data, 4, 4);
18     gsl_vector_view b = gsl_vector_view_array(b_data, 4);
19 
20     // Print the values of A and b using GSL print functions
21     std::cout << "A = \n";
22     gsl_matrix_fprintf (stdout, &A.matrix, "%lf");
23 
24     std::cout << "\nb = \n";
25     gsl_vector_fprintf (stdout, &b.vector, "%lf");
26 
27     // Allocate memory for the solution vector x and the permutation perm:
28     gsl_vector *x = gsl_vector_alloc (4);
29     gsl_permutation *perm = gsl_permutation_alloc (4);
30 
31     // Decompose A into the LU form:
32     int signum;
33     gsl_linalg_LU_decomp (&A.matrix, perm, &signum);
34 
35     // Solve the linear system
36     gsl_linalg_LU_solve (&A.matrix, perm, &b.vector, x);
37 
38     // Print the solution
39     std::cout << "\nx = \n";
40     gsl_vector_fprintf (stdout, x, "%lf");
41 
42     // Release the memory previously allocated for x and perm
43     gsl_vector_free(x);
44     gsl_permutation_free(perm);
45 }

This is how you can compile the above program on a Linux machine:

1 g++ -std=c++17 -Wall -pedantic gsl_test.cpp -o gsl_test -lgsl -lgslcblas

and on a macOS machine:

1 clang++ -std=c++17 -Wall -pedantic gsl_test.cpp -o gsl_test -lgsl -lgslcblas

Here is an example of what I see on a Linux machine when I build and run the above program:

 1 ~$ g++ -std=c++17 -Wall -pedantic gsl_test.cpp -o gsl_test -lgsl -lgslcblas
 2 ~$ ./gsl_test
 3 A = 
 4 0.570929
 5 0.003135
 6 0.880692
 7 0.396265
 8 0.333360
 9 0.018763
10 0.122286
11 0.400857
12 0.555345
13 0.540901
14 0.858480
15 0.621549
16 0.641115
17 0.889268
18 0.589223
19 0.328583
20 
21 b = 
22 1.542669
23 0.749617
24 2.214320
25 2.149894
26 
27 x = 
28 0.864758
29 0.945630
30 0.799511
31 0.862723
32 ~$

For Windows, create a new C++ console application and replace the C++ code generated by Visual Studio with the above C++ program. Since we’ve installed GSL with vcpkg, Visual Studio knows where to find the include files and with what library to link the project, all you have to do is build and run the program.

Here is an example of what I see on a Windows machine:

Create a C++ GSL CMake based project:

In the last part of the article, I will show you how to create a portable C++ and GSL CMake based project that can be used on Windows, macOS and Linux. This is useful if you are interested in running the same project on multiple operating systems.

I will assume that you have a folder named gsl_tests with a C++ program named gsl_test.cpp that contains the code presented in the previous section. In the same folder create a new file named CMakeLists.txt with the next content:

 1 cmake_minimum_required(VERSION 3.10)
 2 
 3 project(gsl_demo)
 4 
 5 set(CMAKE_CXX_STANDARD 17)
 6 set(CMAKE_CXX_STANDARD_REQUIRED True)
 7 
 8 if(MSVC)
 9   add_compile_options(/W4)
10 else()
11   add_compile_options(-Wall -Wextra -pedantic)
12 endif()
13 
14 find_package(GSL REQUIRED)
15 link_libraries(GSL::gsl GSL::gslcblas)
16 
17 
18 add_executable(gsl_demo gsl_test.cpp)

For Linux and macOS, open a Terminal and navigate to the gsl_tests folder:

1 mkdir build && cd build
2 cmake -CMAKE_BUILD_TYPE=Release ..
3 make

You should end up with an executable named gsl_demo in the build folder.

For Windows, go to the Start menu, find the Visual Studio 2019 menu and from it start x64 Native Tools Command Prompt for VS 2019. From the above Command Prompt navigate to where you’ve placed the gsl_tests folder. Here, I will assume for simplicity, that you have the folder gsl_tests in C:\DEV and that your vcpkg installation is also in C:\DEV:

1 cd \
2 cd DEV\gsl_tests
3 mkdir build && cd build
4 cmake -DCMAKE_TOOLCHAIN_FILE=C:/DEV/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_BUILD_TYPE=Release ..

At this point, you can build the project from the same Command Prompt with:

1 msbuild gsl_demo.sln /property:Configuration=Release

and you should end up with an executable named gsl_demo.exe inside the Release folder.

Alternatively, open C:\DEV\gsl_tests\build in Windows Explorer, right click on gsl_demo.sln and chose to open it with Visual Studio 2019. You should see a list of projects, right click on the one named gsl_demo and make it the default one than build it. At this point, you can run the code as usual with CTRL + F5, F5 or from the Debug menu.

As a side note, latest Visual Studio installer should install cmake for you. If you get an error when trying to use cmake with the above instructions, first check that you are using a proper Visual Studio command prompt. If you still can’t find cmake, you can install it from https://cmake.org/, just be sure to add it to the Windows path.

If you need to learn about Linear Algebra, I would recommend reading Linear Algebra and Learning from Data by Gilbert Strang:

If you want to learn more about C++17 I would recommend reading C++17 in Detail by Bartlomiej Filipek:

Install Code::Blocks and GCC 9 on Windows - Build C, C++ and Fortran programs

2019-11-16 11:17:35 +0000

In this article I will show you how to install the Code::Blocks IDE on Windows and how to configure it to use GCC 9 for building C, C++ and Fortran programs. The advantage of this setup is that you will be able to compile any standard C99, C11, C++11, C++14, C++17 and Fortran program on your Windows machine. Please note, that Code::Blocks is available in two versions: as a standalone IDE, as an IDE and an outdated version of GCC (5.1.0). I will show you how to use the latest version of GCC, which is 9.2 at the time of this writing, with the Code::Blocks IDE.

I recommend that you start by installing the latest version of GCC, by following my previous article, in which I’ve shown how to install GCC 9.2 with the MSYS2 software distribution. Once you have GCC installed, you can proceed with installing Code::Blocks.

There is also a video version of this tutorial:

The article consists of five parts:

Install the Code::Blocks IDE:

From the Downloads section of Code::Blocks select Download the binary release. On this page, select the version of the installer that doesn’t contain mingw in his name, typically this is the first option:

Start the installation process and accept all defaults. At the end of the installation you will get an error about not finding a compiler, ignore the message and close this window.

Configure Code::Blocks for building C and C++ programs:

Let’s configure Code::Blocks for building C and C++ programs. Open Code::Blocks and go to Settings → Compiler:

Select the Toolchain executables: first change the first three names starting with mingw32- by removing the above prefix and second change the Compiler’s installation directory to point to the MSYS2 installation directory, in my case this is C:\msys64\mingw64. You can see the default settings in the next image:

Here are the file names after I’ve removed the mingw32- prefix and changed the compiler’s installation directory:

Please note that the Make program entry remained unchanged!

Press OK (lower right corner) to register the changes.

Building a C++ project with Code::Blocks:

Let’s see how you can create a new C++ project. Go to File → New → Project, select Console application and press Go:

On the next page, read the description of the project type and press Next. Select C++ (this should be selected by default) and press Next again.

Now, give a descriptive title to the project and select where you want the project to be saved, I’ve used Hello for name and C:\DEV for the project path:

Press Next and, on the final page, accept the defaults and press Finish:

Next, go to the left panel, press the plus button to unfold Sources and double click on main.cpp to make it visible in the editor area. You should see a default hello world source code. Use the small green triangle button to build and run the project:

Please note that the left, slightly larger, green triangle button is used to Run an already compiled program. If you change something in your code, save it and use the Build and Run button to generate a new executable.

If you have no error, a console window will open and show you the result of running the program:

By default, GCC 9 compiles your C++ code using the C++14 standard, for C programs the default standard is C11. If you want to use the latest C++17 standard you will need to set a compiler flag. You can do this from Settings → Compiler and Compiler Flags. Right click on one of the Have g++ follow … lines and select New flag:

press OK and make sure the right rectangle is checked:

press OK to register the changes.

Now, when you press Build and Run the compiler will use the C++17 standard. This change will persist between projects, if you need to use an older standard remember to deselect the C++17 flag.

Configure Code::Blocks for building Fortran programs:

Go to Settings → Compiler:

Change the Selected compiler from GNU GCC Compiler to GNU Fortran Compiler. Next, select the Toolchain executables: first change the first three names starting with mingw32- by removing the above prefix and second change the Compiler’s installation directory to point to the MSYS2 installation directory, in my case this is C:\msys64\mingw64. You can see the default settings in the next image:

Here are the file names after I’ve removed the mingw32- prefix and changed the compiler’s installation directory:

Please note that the Make program entry remained unchanged!

Press OK (lower right corner) to register the changes.

Building a Fortran project with Code::Blocks:

Next, I will show you how to build and run a Fortran project from the Code::Blocks IDE.

Let’s see how you can create a new C++ project. Go to File → New → Project, select Fortran application and press Go:

On the next page, read the description of the project type and press Next.

Now, give a descriptive title to the project and select where you want the project to be saved, I’ve used HelloFortran for name and C:\DEV for the project path:

Press Next and make sure to change the Compiler to be GNU Fortran Compiler:

If you are satisfied with the other settings press Finish.

Next, go to the left panel, press the plus button to unfold Fortran Sources and double click on main.f90 to make it visible in the editor area. Change the default Fortran example to something like this:

1 program HelloWorld
2     implicit none
3     integer:: a = 20, b = 45
4     print*, 'Hello World from Fortran!'
5     print*, 'a + b = ', a + b
6 end program

Use the small green triangle button to build and run the project:

If you have no error, a console window will open and show you the result of running the program:

If you want to learn more about C++17 I would recommend reading C++17 in Detail by Bartlomiej Filipek:

If you need to brush your Fortran knowledge a good book is Modern Fortran Explained by M. Metcalf, J. Reid and M. Cohen:

C++ Implementing a Chaos Game simulator

2019-11-13 16:47:12 +0000

In this article, I will show how to implement in C++ the classical Chaos Game. We start with a regular polygon and a random initial point inside the polygon. Next, we randomly select one of the polygon vertices and add a new point at a fraction of the distance between the initial point and the polygon vertex. We take as initial point the newly generated point and iterate for a large number of steps. Following the above process can, in some cases, produce a fractal shape.

In the next image you can see various fractal shapes generated with the program we are going to write in this post:

Before writing the actual code, we need to decide how we are going to visualize the results of our simulation. In the first version of this code, I’ve saved the points in a text file and visualized the results using a separate Python and Matplotlib script, but this was slow and cumbersome to use, especially in the debugging phase.

A better approach is to save the result of a simulation directly as an image from the C++ program. This makes the code easier to share with other people and it is also faster to iterate during development. An even better approach will be to use a library like SDL2 to visualize a result as soon as it is generated. In this article, we are going to implement two graphical backends for the simulator - one based on a saving the result as a BMP image and one based on drawing the generated points using SDL2.

Another problem that we need to solve is how to map the points from the world, or the real space, to the 2D screen space of our computer. For our simulator, the world space is contained by the [-1, 1] x [-1, 1] square. Another element to keep in mind is that different graphical libraries or image formats have different conventions about how the Y axis is oriented. For example, most image formats will have the Y pointing down - the BMP image format we are going to use can have Y pointing down or up, but it is typically used with Y pointing up and the origin in the lower left corner. SDL2, on the other hand, uses the convention that the Y axis points down with the origin in the upper left corner.

A linear mapping between the world space and the screen space can be defined by the next relations:

\[x_{screen\_space} = A \cdot x_{world} + C\] \[y_{screen\_space} = B \cdot y_{world} + D\]

where:

\[A = {(S_{right} - S_{left}) \over (W_{right} - W_{left})}\] \[B = {(S_{top} - S_{bottom}) \over (W_{top} - W_{bottom})}\] \[C = S_{left} - A \cdot W_{left}\] \[D = S_{bottom} - B \cdot W_{bottom}\]

You can find the complete code in the GitHub repository for this article.

In order to implement the above relations, we need a way to represent 2D points and rectangles:

 1 // File "geometry.h"
 2 #pragma once
 3 
 4 struct Point2D {
 5     double x;
 6     double y;
 7 };
 8 
 9 struct Rectangle2D {
10     double left;
11     double bottom;
12     double right;
13     double top;
14 
15     Rectangle2D(double left, double bottom, double right, double top)
16     : left{left}, bottom{bottom}, right{right}, top{top} {}
17 };

Now, we can implement the mapping from the world to the screen space:

 1 // File "geometry.h"
 2 #pragma once
 3 
 4 struct Point2D {
 5     // ...
 6 };
 7 
 8 struct Rectangle2D {
 9     // ...
10 };
11 
12 // ...
13 // Note: The mapping holds even when the screen space has the Y axis pointing down
14 // (in which case top = 0 and bottom = height).
15 struct World_to_ScreenSpace {
16     double A;
17     double B;
18     double C;
19     double D;
20 
21     World_to_ScreenSpace(const Rectangle2D &world, const Rectangle2D &screen_space) {
22         A = (screen_space.right - screen_space.left) / (world.right - world.left);
23         B = (screen_space.top - screen_space.bottom) / (world.top - world.bottom);
24         C = screen_space.left - A * world.left;
25         D = screen_space.bottom - B * world.bottom;
26     }
27 
28     Point2D mapping(const Point2D p) const {
29         Point2D sp;
30         sp.x = A * p.x + C;
31         sp.y = B * p.y + D;
32         return sp;
33     }
34 
35     Point2D mapping(double x, double y) const {
36         Point2D sp;
37         sp.x = A * x + C;
38         sp.y = B * y + D;
39         return sp;
40     }
41 };

Let’s test the above transform by writing a driver test for our two backends. I want to chose between the two backends at compile time, this will let other people build the program even when they don’t have the SDL2 library installed. For the BMP backend I will use the code from my previous article.

For this test, we are going to define a world space [0, 800) x [0, 800) and a square, screen space, with an 800 x 800 pixels surface. The test will consist in drawing 11 points diagonally from (0, 0) to (799, 799):

 1 // File "backend_test.cpp"
 2 
 3 #include <iostream>
 4 #include <vector>
 5 
 6 #include "geometry.h"
 7 
 8 #ifdef USE_SDL2_BACKEND
 9     #include "backend_sdl2.h"
10 #else
11     #include "backend_bmp.h"
12 #endif
13 
14 constexpr int width = 800;
15 constexpr int height = 800;
16 
17 int main(int argc, char **argv) {
18     Rectangle2D world{0, 0, 800, 800};
19     std::vector<Point2D> points{ {0, 0}, {10, 10}, {20, 20}, {30, 30}, {40, 40}, {50, 50}, {60, 60}, {70, 70}, {80, 80}, {90, 90}, {799, 799} };
20 
21 #ifdef USE_SDL2_BACKEND
22     Rectangle2D screen_space{0, static_cast<double>(height - 1), static_cast<double>(width - 1), 0};
23     backend_sdl2(width, height, world, screen_space, points, 5);
24 #else
25     Rectangle2D screen_space{0, 0, static_cast<double>(width - 1), static_cast<double>(height - 1)};
26     backend_bmp("chaos.bmp", width, height, world, screen_space, points, 5);
27 #endif
28 }

For the remaining of this article, I’ll assume that you have the code from my C++ reading and writing BMP images in your working folder. Specifically, you’ll need at least cpp-bmp-images/BMP.h.

The BMP backend header file will define a backend_bmp function that will take as arguments the output BMP file name, the width and height of the image, the world and screen_space, a vector with points to be drawn and a so called point radius which is the size in pixels of a point. The last parameter is useful only for debugging purposes in order to better see what it is actually drawn on the image, by default a point will be drawn as 1 x 1 pixel.

 1 // File "backend_bmp.h"
 2 
 3 #pragma once
 4 
 5 #include <vector>
 6 #include "geometry.h"
 7 
 8 void backend_bmp(const char *file_name, int width, int height,
 9                  const Rectangle2D &world,
10                  const Rectangle2D &screen_space,
11                  const std::vector<Point2D> &points,
12                  int point_radius);

The implementation of the BMP backend starts by creating a width x height BMP surface and fill it with white. Next, we convert the points to be drawn to the screen space using the above mapping. We draw every point from the input vector in black on the BMP image. If point_radius is larger than 0 a crude filled “circle” is drawn around the point. Finally, we save the image to the disk.

 1 // File "backend_bmp.cpp"
 2 
 3 #include "backend_bmp.h"
 4 #include "cpp-bmp-images/BMP.h"
 5 
 6 // Transform/Map/Convert the points elements to the screen space
 7 static std::vector<Point2D> points_to_screen_space(int width, int height, const Rectangle2D &world, const Rectangle2D &screen_space, const std::vector<Point2D> &points) {
 8 
 9     // ... See the code on the Github repo for this article
10 }
11 
12 // Draw a "crude" circle around the point p
13 static void drawPointWithSize(BMP &bmp, int width, int height, const Point2D &p, int radius) {
14 
15     // ... See the code on the Github repo for this article
16 
17 }
18 
19 void backend_bmp(const char *file_name, int width, int height, const Rectangle2D &world, const Rectangle2D &screen_space, const std::vector<Point2D> &points, int point_radius) {
20     BMP bmp(width, height, false);
21     bmp.fill_region(0, 0, width, height, 255, 255, 255, 255);
22 
23     std::vector<Point2D> p = points_to_screen_space(width, height, world, screen_space, points);
24 
25     if(point_radius == 0) {
26         for(size_t i = 0; i < p.size(); ++i) {
27             bmp.set_pixel(p[i].x, p[i].y, 0, 0, 0, 255);
28         }
29     } else {
30         for(size_t i = 0; i < p.size(); ++i) {
31             drawPointWithSize(bmp, width, height, p[i], point_radius);
32         }
33     }
34 
35     bmp.write(file_name);
36 }

You can build the above code on Linux, macOS, WSL or Windows with MSYS2 like this:

1 clang++ -std=c++17 -stdlib=libc++ -Wall -pedantic backend_bmp.cpp backend_test.cpp

or, with g++:

1 g++ -std=c++17 -Wall -pedantic backend_bmp.cpp backend_test.cpp

If you are using MSVC on Windows, build it with:

1 cl /std:c++17 /W3 /permissive- /EHsc backend_bmp.cpp backend_test.cpp /Fe:backend_test.exe

This is what you should see, if you run the above code:

The SDL2 backend is similar with the BMP, except that instead of saving the result in a BMP image a window is shown in which you can see the points drawn. Here is a snipped from backend_sdl2.cpp, remember to define USE_SDL2_BACKEND if you want to be able to build the SDL2 backend.

 1 // File "backend_sdl2.cpp"
 2 
 3 #include <SDL2/SDL.h>
 4 #include "backend_sdl2.h"
 5 #include <iostream>
 6 
 7 // Transform/Map/Convert the points elements to the screen space
 8 static std::vector<SDL_Point> points_to_screen_space(int width, int height, const Rectangle2D &world, const Rectangle2D &screen_space, const std::vector<Point2D> &points) {
 9     // ... See the code on the Github repo for this article
10 }
11 
12 // Draw a "crude" circle around the point p
13 static void drawPointWithSize(SDL_Renderer *renderer, int width, int height, const SDL_Point &p, int radius) {
14     // ... See the code on the Github repo for this article
15 }
16 
17 void backend_sdl2(int width, int height, const Rectangle2D &world, const Rectangle2D &screen_space, const std::vector<Point2D> &points, int point_radius) {
18     // Initialize SDL
19     SDL_Init(SDL_INIT_VIDEO);
20 
21     // Create a SDL window
22     SDL_Window *window = SDL_CreateWindow("Chaos Game", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_SHOWN);
23 
24     // Create a renderer (accelerated and in sync with the display refresh rate)
25     SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
26 
27     // Convert points to SDL2 window and axis orientation
28     std::vector<SDL_Point> p = points_to_screen_space(width, height, world, screen_space, points);
29 
30     bool running = true;
31     SDL_Event event;
32     while(running) {
33         // Process events
34         while(SDL_PollEvent(&event)) {
35             if(event.type == SDL_QUIT) {
36                 running = false;
37             } else if (event.type == SDL_KEYDOWN) {
38                 switch(event.key.keysym.sym) {
39                     case SDLK_q:
40                     running = false;
41                     break;
42                 }
43             }
44         }
45 
46         // Clear screen
47         SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
48         SDL_RenderClear(renderer);
49 
50         // Draw
51         SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
52 
53         if(point_radius == 0) {
54             SDL_RenderDrawPoints(renderer, &p[0], p.size());
55         } else {
56             for(const SDL_Point &e : p) {
57                 drawPointWithSize(renderer, width, height, e, point_radius);
58             }
59         }
60 
61         // Show what was drawn
62         SDL_RenderPresent(renderer);
63     }
64 
65     // Release resources
66     SDL_DestroyRenderer(renderer);
67     SDL_DestroyWindow(window);
68     SDL_Quit();
69 }

You can build the above code with the SDL2 backend on Linux, macOS, WSL or Windows with MSYS2 like this:

1 clang++ -std=c++17 -stdlib=libc++ -Wall -pedantic backend_sdl2.cpp -DUSE_SDL2_BACKEND backend_test.cpp `pkg-config --cflags --libs sdl2`

or, with g++:

1 g++ -std=c++17 -Wall -pedantic backend_sdl2.cpp -DUSE_SDL2_BACKEND backend_test.cpp `pkg-config --cflags --libs sdl2`

If you are using MSVC on Windows, I recommend to install SDL2 globally with vcpkg and use Visual Studio to create a project. You can also build from the command line, but it is more tedious and you’ll need to manually link with the library and instruct the compiler where to find the header files.

As mentioned at the beginning of the article, we are going to use regular polygons to contain the generated set of points. In order to do this we need a way to define a regular polygon.

Remember that a regular polygon is a polygon that is equiangular (all angles are equals) and equilateral (all edges are equals).

For simplicity, we’ll consider regular polygons inscribed in a circle with radius 1.0 and center at (0, 0). This means that all vertices of the polygon will be on this circle.

The center angle of a polygon is the angle made at the center by any two adjacent vertices of the polygon. For a regular polygon the center angle is:

\[\alpha = {360^{\circ} \over no_{edges}}\]

For example, for an equilateral triangle a center angle is 120 degrees, for a square it is 90 degrees, for a regular hexagon it is 60 degrees and so on.

This means, that we can calculate the position of every vertex of a regular polygon using the parametric equation of a circle with radius 1 and center at (0, 0). We just need to add the center angle for every vertex.

Say that we want to calculate the vertices of an equilateral triangle. If we start with the first vertex from (0, 1), the second vertex will have the coordinates:

\[x = 1 \cdot cos(90^{\circ} + 120^{\circ}) = cos(210^{\circ}) = -0.866\] \[y = 1 \cdot sin(90^{\circ} + 120^{\circ}) = sin(210^{\circ}) = -0.5\]

for the third vertex:

\[x = 1 \cdot cos(210^{\circ} + 120^{\circ}) = cos(330^{\circ}) = 0.866\] \[y = 1 \cdot sin(210^{\circ} + 120^{\circ}) = sin(330^{\circ}) = -0.5\]

We can implement the above considerations in a struct named RegularPolygon:

 1 // File "geometry.h"
 2 
 3 #pragma once
 4 #include <cmath>
 5 #include <vector>
 6 
 7 struct Point2D {
 8     // ...
 9 };
10 
11 struct Rectangle2D {
12     // ...
13 };
14 
15 struct RegularPolygon {
16     int nr_edges = 3;
17     double radius = 1.0;
18     double start_angle = 90.0;
19     double angle = 120.0;
20     std::vector<Point2D> points;
21 
22     // default create an equilateral triangle
23     RegularPolygon() {
24         points.resize(nr_edges);
25         init_points();
26     }
27 
28     RegularPolygon(int nr_edges, double radius = 1.0) : nr_edges{nr_edges}, radius{radius} {
29         points.resize(nr_edges);
30         angle = 360.0 / nr_edges;
31         // We change the start_angle in order to have the lower edge
32         // of every polygon parallel with the horizontal axis
33         if(nr_edges % 2 == 0) {
34             start_angle += angle / 2.0;
35         }
36         init_points();
37     }
38 
39     void init_points() {
40         // in C++20 and up replace with std::pi from <numbers>
41         const double PI = acos(-1.0);
42         const double deg_rad = PI/180.0;
43 
44         double current_angle = start_angle * deg_rad;
45         double min_y = 2.0;
46         for(int i = 0; i < nr_edges; ++i) {
47             points[i].x = radius * cos(current_angle);
48             points[i].y = radius * sin(current_angle);
49             if(min_y > points[i].y) min_y = points[i].y;
50             current_angle += angle * deg_rad;
51         }
52 
53         // Center the points vertically
54         double offset = (2.0 - (1.0 - min_y))/2.0;
55         if(nr_edges % 2 != 0) {
56             for(int i = 0; i < nr_edges; ++i) {
57                 points[i].y -= offset;
58             }
59         }
60     }
61 };
62 
63 struct World_to_ScreenSpace {
64     // ...
65 };

We can test the above code with the polygons_test.cpp driver. This is basically, backend_test.cpp slightly modified to use a different world [-1, -1] x [1, 1] and to draw the polygon vertices:

 1 // File "polygons_test.cpp"
 2 
 3 // ...
 4 
 5 int main(int argc, char **argv) {
 6     Rectangle2D world{-1.08, -1.08, 1.08, 1.08};
 7     RegularPolygon pp(8);
 8 
 9 #ifdef USE_SDL2_BACKEND
10     Rectangle2D screen_space{0, static_cast<double>(height - 1), static_cast<double>(width - 1), 0};
11     backend_sdl2(width, height, world, screen_space, pp.points, 5);
12 #else
13     Rectangle2D screen_space{0, 0, static_cast<double>(width - 1), static_cast<double>(height - 1)};
14     backend_bmp("chaos.bmp", width, height, world, screen_space, pp.points, 5);
15 #endif
16 }

If you build and run the above code, you should see the vertices of an octagon:

At this point, we are ready to implement the rules for the game of chaos:

Generate the vertices of a regular polygon.
Take a random point inside the above polygon. For simplicity, we’ll take this as the first vertex of the polygon.
Pick a random vertex of the polygon.
Take the next point at a ratio between the last point and the random polygon vertex. Here, you can add more rules, for example that the last and the next vertex randomly selected from the polygon should be different. If they are the same, simply reject the generated point.
Repeat the above steps for a large number of iterations.

When you plot the generated points, drop the first couple of them.

We can implement the above rules as ChaosGame:

 1 // File "ChaosGame.cpp"
 2 
 3 #pragma once
 4 #include <random>
 5 #include <functional>
 6 #include "geometry.h"
 7 
 8 struct ChaosGame {
 9     static const int max_iterations = 100'000;
10     static const int ignore_first_iterations = 10;
11 
12     Point2D last_point;
13     int last_vertex;
14     RegularPolygon polygon;
15 
16     std::uniform_int_distribution<int> uniform_dist;
17     std::mt19937_64 engine;
18 
19     ChaosGame(const RegularPolygon &poly) {
20         polygon = poly;
21 
22         last_point = polygon.points[0];
23         last_vertex = 0;
24 
25         std::random_device r;
26         std::mt19937_64 eng(r());
27         std::uniform_int_distribution<int> distr(0, polygon.nr_edges - 1);
28         uniform_dist = distr;
29         engine = eng;
30     }
31 
32     Point2D get_next_point(const std::function<bool (int, int, int)> &func, double ratio = 0.5, int dist = 0) {
33         Point2D point;
34         bool running = true;
35         int remove_iter = 0;
36         while(running) {
37             int random_vertex = uniform_dist(engine);
38             if(func(random_vertex, last_vertex, dist)) {
39                 point.x = (last_point.x + polygon.points[random_vertex].x) * ratio;
40                 point.y = (last_point.y + polygon.points[random_vertex].y) * ratio;
41 
42                 last_vertex = random_vertex;
43                 last_point = point;
44                 remove_iter++;
45                 if(remove_iter >= ignore_first_iterations) {
46                     running = false;
47                 }
48             }
49         }
50         return point;
51     }
52 };
53 
54     // ...

In the above code, we chose to run for 100000 iterations and drop the first 10 generated points. Next, we pick as the last point the first vertex of the polygon and as the last vertex the same. We initialize a random generation engine and an uniform distribution to pick a random vertex of the polygon.

The get_next_point member function picks a random vertex and checks if this vertex can be used, than it takes a new point at a fraction of the distance between the last point and the vertex. The function also drops the first couple of points generated.

Next, we implement a free function that generates the points. The full code has 14 rules for generating 14 different fractal shapes. In the next snippet, we present the first two rules, or selections:

 1 // File "ChaosGame.cpp"
 2 
 3 #pragma once
 4 #include <random>
 5 #include <functional>
 6 #include "geometry.h"
 7 
 8 struct ChaosGame {
 9     // ...
10 };
11 
12 inline int generate_points(std::vector<Point2D> &points, int selection = 0) {
13     // wrap the values for selection values larger than the number of implemented selections
14     if(selection > 14) {
15         selection = 0;
16     }
17 
18     // default selection = 0 settings
19     int nr_edges = 3;
20     double ratio = 0.5;
21     int distance = 0;
22     std::function<bool (int, int, int)> func = [] (int random_vertex, int last_vertex, int dist) -> bool {return true;};
23 
24     if(selection == 1) {
25         func = [] (int random_vertex, int last_vertex, int dist) -> bool {return (std::abs(random_vertex - last_vertex) != dist);};
26         nr_edges = 4;
27         ratio = 0.5;
28         distance = 0;
29     }
30 
31     // ... See the code on the Github repo for this article
32 
33     RegularPolygon polygon(nr_edges);
34     ChaosGame chaos(polygon);
35 
36     for(auto &p : points) {
37         p = chaos.get_next_point(func, ratio, distance);
38     }
39 
40     return selection;
41 }

If you call generate_points with the default selection = 0 it will generate the Sierpinski triangle.

We can modify polygons_test.cpp in order to use the ChaosGame.h and draw the generated points.

 1 // File "main.cpp"
 2 
 3 #include <iostream>
 4 #include <vector>
 5 #include <string>
 6 
 7 #include "geometry.h"
 8 #include "ChaosGame.h"
 9 
10 #ifdef USE_SDL2_BACKEND
11     #include "backend_sdl2.h"
12 #else
13     #include "backend_bmp.h"
14 #endif
15 
16 constexpr int width = 800;
17 constexpr int height = 800;
18 
19 int main(int argc, char **argv) {
20     Rectangle2D world{-1.08, -1.08, 1.08, 1.08};
21 
22     std::vector<Point2D> points(ChaosGame::max_iterations);
23 
24     int selection = 0;
25     if(argc >= 2) {
26         int sel = std::stoi(argv[1]);
27         selection = sel >= 0 ? sel : 0;
28     }
29 
30     generate_points(points, selection);
31 
32 #ifdef USE_SDL2_BACKEND
33     Rectangle2D screen_space{0, static_cast<double>(height - 1), static_cast<double>(width - 1), 0};
34     backend_sdl2(width, height, world, screen_space, points, 0);
35 #else
36     Rectangle2D screen_space{0, 0, static_cast<double>(width - 1), static_cast<double>(height - 1)};
37     std::string fname = "chaos_" + std::to_string(selection) + ".bmp";
38     backend_bmp(fname.c_str(), width, height, world, screen_space, points, 0);
39 #endif
40 }

When you run the above program, you can pass your selection of the rule to use from 0 to 14. If you pass a wrong number the program will try to correct the value. Running the program without a numeric parameter will use the first selection and generate the Sierpinski triangle.

Here is an example of building and running the program with the BMP backend:

1 clang++ -std=c++17 -stdlib=libc++ -Wall -pedantic backend_bmp.cpp main.cpp -o main
2 ./main 3

This is what you should see if you pass the number 3 to the program:

The code repository for this article contains a folder interactive that uses the SDL2 backend to let you go back and forth in the available shapes selections. Hint - use the left/right arrow keys to navigate.

If you want to learn more about C++17 I would recommend reading C++17 in Detail by Bartlomiej Filipek:

or, C++17 - The Complete Guide by Nicolai M. Josuttis:

Install GCC 9 on Windows - Build C, C++ and Fortran programs

2019-11-05 09:34:45 +0000

In this article, I will show you how the install the GCC compilers on your Windows system using the MSYS2 software distribution.

The advantage of this setup is that you will be able to build C, C++ and Fortran programs on your Windows machine and generate native Windows executables. Also, MSYS2 tends to offer the latest stable versions of GCC, which at the time of this writing is 9.2.

There is also a video version of this tutorial:

Another advantage of using the MSYS2 software distribution is that you will be able to install, if necessary, other C and C++ libraries like SDL2 or OpenCV using the pacman package manager which is included with MSYS2.

Please note that all graphical libraries provided by MSYS2 use the native Win32 API. This means that when you build for example an OpenGL application it will use a native Windows Win32 window.

Get the MSYS2 installer. I recommend to use the 64 bits version if possible:

Once the download is finished, start the installer and accept the defaults. You should end up with a screen that asks if you want to Run MSYS2 64bit now., make sure it is checked and press Finish.

After the above step, a command window, or a Terminal, should open. Write this in the MSYS Terminal:

1 $ pacman -Syu

and write Y when asked if you want to proceed with the installation. This should update the base system.

If you get an error with the above command, try this approach:

1 $ pacman -Sydd filesystem
2 $ pacman -Su

When finished, you should see a message about closing your terminal window. Use the X button to close the window.

Next, from your Windows Start menu, go to MSYS2 64 bit → MSYS2 MSYS:

Please note, that in the above image you have three entries, the MSYS2 MSYS is the one you will want to use every time you need to install a package, search for a package or upgrade a package with the pacman package manager.

Repeat the above command to finish the system upgrade:

1 $ pacman -Syu

Once the update is finished, you are ready to search and install packages using the pacman package manager. For example, if you want to search for gcc use the next command:

1 $ pacman -Ss gcc

you should see a long list with all available packages that contain the gcc string. We are interested in the 64 bits packages only, so a better option is to filter the results to show only the ones that contain the mingw64 string:

1 $ pacman -Ss gcc | grep mingw64

Now, the list of packages is cleaner and only shows the 64 bits versions. This is what I see on my machine, as of November 2019. You will probably see slightly newer versions of the packages:

1 $ pacman -Ss gcc | grep mingw64
2 mingw64/mingw-w64-x86_64-gcc 9.2.0-2 (mingw-w64-x86_64-toolchain)
3 mingw64/mingw-w64-x86_64-gcc-ada 9.2.0-2 (mingw-w64-x86_64-toolchain)
4 mingw64/mingw-w64-x86_64-gcc-fortran 9.2.0-2 (mingw-w64-x86_64-toolchain)
5 mingw64/mingw-w64-x86_64-gcc-libgfortran 9.2.0-2 (mingw-w64-x86_64-toolchain)
6 mingw64/mingw-w64-x86_64-gcc-libs 9.2.0-2 (mingw-w64-x86_64-toolchain)
7 mingw64/mingw-w64-x86_64-gcc-objc 9.2.0-2 (mingw-w64-x86_64-toolchain)
8 mingw64/mingw-w64-x86_64-lcov 1.14-1
9 mingw64/mingw-w64-x86_64-perl 5.28.0-1

From the above, we see that the GCC 9.2 compiler is available in a larger group of packages named mingw-w64-x86_64-toolchain. Let’s install it:

1 $ pacman -S mingw-w64-x86_64-toolchain

Press Enter to select the defaults when asked what you want to install from this group. Write Y when asked if you want to proceed with the installation.

Optionally, if you know that you need a Terminal based text editor like nano or vim you can install it with:

1 $ pacman -S vim

or:

1 $ pacman -S nano

Optionally, if you know that you need it, you can install the Clang compiler with:

1 $ pacman -S mingw-w64-x86_64-clang

We are done with the installation. Write exit in the MSYS2 Terminal to exit cleanly:

1 $ exit

Next, when you want to compile and run C, C++ or Fortran programs you will need to go to Windows Start → MSYS2 64 bit → MSYS2 MinGW 64-bit:

be careful which option you select, otherwise you will get errors when you try to use the compilers.

Check GCC’s version with:

1 $ gcc --version

This is what I see, on my machine:

1 $ gcc --version
2 gcc.exe (Rev2, Built by MSYS2 project) 9.2.0
3 Copyright (C) 2019 Free Software Foundation, Inc.
4 This is free software; see the source for copying conditions.  There is NO
5 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Similarly, you can check gfortran’s version, with:

1 $ gfortran --version
2 GNU Fortran (Rev2, Built by MSYS2 project) 9.2.0
3 Copyright (C) 2019 Free Software Foundation, Inc.
4 This is free software; see the source for copying conditions.  There is NO
5 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

By default, your MSYS2 MinGW 64-bit Terminal starts in your home folder (like on a macOS or Linux system). You can find the MSYS2 home folder from Windows by going to C:\msys2\home\user_name where user_name is your user’s name.

You can go to your home folder from the MSYS2 MinGW 64-bit Terminal with:

1 $ cd ~

Next, create or add a C++ program named fs_test.cpp into your home folder with the next content:

1 #include <iostream>
2 #include <filesystem>
3 
4 int main() {
5     for(auto &file : std::filesystem::recursive_directory_iterator("./")) {
6         std::cout << file.path() << '\n';
7     }
8 }

The above program uses C++17 Filesystem to recursively list all files and directories from your home.

Double check that you have a C++ file named fs_test.cpp in your home folder:

1 $ cd ~
2 $ ls

If you see the above file name, you are ready to build it. This is how to compile it using GCC:

1 $ g++ -std=c++17 -Wall -Wextra -pedantic fs_test.cpp -o fs_test

If you see no error, run the generated executable with:

1 $ ./fs_test

Here is an example of a simple Fortran program:

1 program hello
2     implicit none
3     real:: x = 2.5, y = 4.0
4     print*, "Hello, from Fortran!"
5     print*, "x + y = ", x + y
6 end program hello

save the program as hello.f90 and build it with:

1 $ gfortran hello.f90 -o hello

This is what I see if I run the above program:

1 $ ./hello
2  Hello, from Fortran!
3  x + y =    6.50000000

A word of warning, GCC and Clang under MSYS2 have some platform limitations, for example you can’t use the sanitizers, Clang needs to use the C++ standard library provided by GCC and so on … If you want the full GCC or Clang experience you will need to use Linux or macOS. On Windows you can also install WSL or install a Linux distribution in a virtual machine. Another option is to install Cygwin.

If you want to learn more about C++17 I would recommend reading C++17 in Detail by Bartlomiej Filipek:

If you need to brush your Fortran knowledge a good book is Modern Fortran Explained by M. Metcalf, J. Reid and M. Cohen:

C++20 span tutorial

2019-11-03 15:12:12 +0000

According to the latest C++20 draft, a span is a non-owning view over a contiguous sequence of objects. In other words, a std::span is, in essence, a pointer, length pair that gives the user a view into a contiguous sequence of elements. The elements of a span can be, for example, stored in one of the standard library sequential containers (like std::array, std::vector), in a built-in C-style array or in a memory buffer.

Here is a simple example of using std::span as a general interface for a print function that receives as argument a contiguous sequence of integers:

 1 // span_0.cpp
 2 #include <iostream>
 3 #include <vector>
 4 #include <array>
 5 #include <span>
 6 
 7 void print_content(std::span<int> container) {
 8     for(const auto &e : container) {
 9         std::cout << e << ' ';
10     }
11     std::cout << '\n';
12 }
13 
14 int main() {
15     int a[]{23, 45, 67, 89};
16     print_content(a);
17 
18     std::vector v{1, 2, 3, 4, 5};
19     print_content(v);
20 
21     std::array a2{-14, 55, 24, 67};
22     print_content(a2);
23 }

This is what I see if I build and run the above file on a Linux machine with Clang 9:

1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_0.cpp
2 $ ./a.out
3 23 45 67 89
4 1 2 3 4 5
5 -14 55 24 67
6 $

At the time of this writing, you can use std::span with Clang 9 and GCC 10, MSVC doesn’t have support for std::span. If you are using a compiler that doesn’t have support for std::span, you can use a 3rd party implementation like @tcbrindle or use the latest Clang or GCC from Compiler Explorer.

Here is an example of modifying the above program for a C++17 compiler. I assume that you’ve saved the span.hpp header from @tcbrindle in the same folder as your span_0.cpp file:

 1 // span_0.cpp
 2 #include <iostream>
 3 #include <vector>
 4 #include <array>
 5 
 6 #if __has_include(<span>)
 7     #include <span>
 8 #else
 9     #include "span.hpp"
10     // UGLY TEMPORARY HACK UNTIL YOUR CURRENT C++ COMPILER INCLUDES std::span SUPPORT
11     namespace std {
12         using tcb::span;
13     }
14 #endif
15 
16 
17 // ... same code as in the previous example

With the above modification, this is how you can build the example with the latest MSVC compiler:

1 C:\DEV> cl /std:c++latest /W4 /permissive- /EHsc span_0.cpp
2 C:\DEV>span_0.exe
3 23 45 67 89
4 1 2 3 4 5
5 -14 55 24 67
6 
7 C:\DEV>

Please note that while std::span doesn’t own the memory storage of the elements, as in you can’t increase or decrease the memory buffer that stores the elements, you can modify the actual elements, e.g.:

 1 // span_1.cpp
 2 
 3 // ... include headers ...
 4 
 5 void print_content(std::span<int> container) {
 6     // ...
 7 }
 8 
 9 void scale_2x_content(std::span<int> container) {
10     for(auto &e : container) {
11         e *= 2;
12     }
13 }
14 
15 int main() {
16     int a[]{23, 45, 67, 89};
17     scale_2x_content(a);
18     print_content(a);
19 
20     std::vector v{1, 2, 3, 4, 5};
21     scale_2x_content(v);
22     print_content(v);
23 
24     std::array a2{-14, 55, 24, 67};
25     scale_2x_content(a2);
26     print_content(a2);
27 }

This is what I see, if I build and run the above program:

1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_1.cpp
2 $ ./a.out
3 46 90 134 178
4 2 4 6 8 10
5 -28 110 48 134
6 $

You can also create a span from a pointer to a memory buffer and a size, e.g. :

 1 // span_2.cpp
 2 #include <iostream>
 3 #include <vector>
 4 #include <array>
 5 #include <span>
 6 #include <memory>
 7 
 8 void print_content(std::span<int> container) {
 9     // ...
10 }
11 
12 void scale_2x_content(std::span<int> container) {
13     // ...
14 }
15 
16 int main() {
17 
18     // ...
19 
20     // Allocate space for 10 integers on the heap
21     size_t sz{10};
22     auto p = std::make_unique<int[]>(sz);
23     // Fill the previously allocated space
24     for(size_t i = 0; i < sz; ++i) {
25         p[i] = static_cast<int>(i);
26     }
27     // Pass a pointer/size pair to functions allow a std::span as the first argument
28     scale_2x_content({p.get(), sz});
29     print_content({p.get(), sz});
30 }

This is what I see, if I build and run the above program:

1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_2.cpp
2 $ ./a.out
3 46 90 134 178
4 2 4 6 8 10
5 -28 110 48 134
6 0 2 4 6 8 10 12 14 16 18
7 $

You can also create subviews, or subspans, from a span and operate on these. Keep in mind that when you modify a span or a subspan element you are actually modifying the original data, e.g.:

 1 // span_3.cpp
 2 #include <iostream>
 3 #include <span>
 4 #include <iterator>
 5 
 6 void print_content(std::span<int> container) {
 7     // ...
 8 }
 9 
10 void scale_2x_content(std::span<int> container) {
11     // ...
12 }
13 
14 int main() {
15     int a[]{44, -15, 45, 67, 89, 66};
16     std::cout << "Original data:\n";
17     print_content(a);
18 
19     // Create a span from a C-style array
20     std::span s1{a, std::size(a)};
21 
22     // Double the subview/subspan elements created from the first 4 elements
23     // of the above s1 span
24     scale_2x_content(s1.first(4));
25     std::cout << "Double the first 4 elements:\n";
26     print_content(a);
27 
28     // Double the subview/subspan elements created from the last 3 elements
29     // of the above s1 span
30     scale_2x_content(s1.last(3));
31     std::cout << "Double the last 3 elements:\n";
32     print_content(a);
33 }

This is what you should see, if you build and run the above code:

1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_3.cpp
2 $ ./a.out
3 Original data:
4 44 -15 45 67 89 66
5 Double the first 4 elements:
6 88 -30 90 134 89 66
7 Double the last 3 elements:
8 88 -30 90 268 178 132
9 $

Say that you want to sort a subspan from an existing contiguous sequence of integers. Here is an example of creating a subspan from an existing C-array, taking a subspan from the above span, without the first and the last elements and sorting the selected subspan:

 1 // span_4.cpp
 2 #include <iostream>
 3 #include <span>
 4 #include <iterator>
 5 #include <algorithm>
 6 
 7 void print_content(std::span<int> container) {
 8     // ...
 9 }
10 
11 int main() {
12     int a[]{44, 45, -15, 89, 6, 66};
13     std::cout << "Original data:\n";
14     print_content(a);
15 
16     // Create a span from a C-style array
17     std::span s1{a, std::size(a)};
18 
19     // Create and print a subspan from the above s1 span
20     // without the first and last elements:
21     std::span s2{s1.subspan(1, s1.size() - 2)};
22     std::cout << "Subspan/subview from the original data without the first and last elements:\n";
23     print_content(s2);
24 
25     // Sort the s2 subspan and print the sorted subspan and the original data:
26     std::sort(s2.begin(), s2.end());
27     std::cout << "Sorted subspan:\n";
28     print_content(s2);
29     std::cout << "Original data, partially sorted:\n";
30     print_content(a);
31 }

This is what you should see, if you build and run the above code:

 1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_4.cpp
 2 $ ./a.out
 3 Original data:
 4 44 45 -15 89 6 66
 5 Subspan/subview from the original data without the first and last elements:
 6 45 -15 89 6
 7 Sorted subspan:
 8 -15 6 45 89
 9 Original data, partially sorted:
10 44 -15 6 45 89 66
11 $

As a side note, don’t confuse C++17 std::string_view with the std::span introduced by C++20. While both are non-owning views, std::string_view is a read-only view.

You can, obviously, create a modifiable span or subspan from a std::string or from a char pointer and a buffer size pair. Here is a simple example, that works only for ASCII strings:

 1 // span_5.cpp
 2 #include <iostream>
 3 #include <span>
 4 #include <string>
 5 #include <cctype>
 6 #include <stdexcept>
 7 
 8 void print_content(std::span<char> container) {
 9     for(const auto &e : container) {
10         std::cout << e;
11     }
12     std::cout << '\n';
13 }
14 
15 void uppersize(std::span<char> container) {
16     for(auto &e : container) {
17         unsigned char tmp = static_cast<unsigned char>(e);
18         if(tmp > 127) {
19             throw std::runtime_error("Error! Undefined conversion for non ASCII input strings!");
20         }
21         e = std::toupper(tmp);
22     }
23 }
24 
25 int main() {
26     std::string site_name{"Solarian Programmer"};
27     std::cout << "Original string:\n";
28     print_content(site_name);
29     std::cout << "Uppersized string:\n";
30     uppersize(site_name);
31     print_content(site_name);
32 
33     std::cout << '\n';
34 
35     char site_subtitle[]{"My programming ramblings"};
36     std::cout << "Original char*:\n";
37     print_content(site_subtitle);
38     std::cout << "Uppersized char*:\n";
39     uppersize(site_subtitle);
40     print_content(site_subtitle);
41 }

This is what you should see, if you build and run the above code:

 1 $ clang++ -std=c++2a -stdlib=libc++ -Wall -Wextra -pedantic span_5.cpp
 2 $ ./a.out
 3 Original string:
 4 Solarian Programmer
 5 Uppersized string:
 6 SOLARIAN PROGRAMMER
 7 
 8 Original char*:
 9 My programming ramblings
10 Uppersized char*:
11 MY PROGRAMMING RAMBLINGS
12 $

You can find the complete source code on the GitHub repository for this article.

If you want to learn more about C++17 I would recommend reading C++17 in Detail by Bartlomiej Filipek:

or, C++17 - The Complete Guide by Nicolai M. Josuttis: