Scientific Computing

Qt GUI can be installed in RHEL-like Linux from the CRB repository.

dnf config-manager --set-enabled crb

dnf install qt6-devel

Qt can be used to build cmake-gui like:

# from CMake source directory
cmake -Bbuild -DBUILD_QtDialog=ON

cmake --build build

This results in “build/bin/cmake-gui” being built.

Popular compilers such as GCC, Clang, and Visual Studio support C++20 modules along with CMake.

We provide a CMake project of recent C++ language standad examples, including C++20 modules.

The C++ standard compiler support table is not always up to date. That’s why we make CMake projects to test compiler support of newer language standard features.

In Python Matplotlib or Matlab, making a plot with log-scaled (instead of default linear-scaled) axes can use the functions like “loglog()”, “semilogx()”, or “semilogy()”. Here we show the more general object-oriented syntax for each of a 2-D line “plot()” and 2-D pseudocolor “pcolor()” and then set the axes scale properties.

We arbitrarily use log abscissa scale and linear ordinate scale, but the same syntax applies to other combinations.

Python

2-D line plot:

import numpy as np
from matplotlib.pyplot import figure, show

x = np.logspace(0, 10, 100)
y = np.log(x)**2

fg = figure()
ax = fg.gca()

ax.plot(x, y)
ax.set_xscale('log')

ax.set_xlabel('x')
ax.set_ylabel('y')

show()

pseudocolor pcolormesh(): observe the stretching of the ticks along the y-axis. In some cases it’s helpful to set the axis limits manually to avoid whitespace past the last data point.

import numpy as np
from matplotlib.pyplot import figure, show

d = np.random.rand(10, 10)
x = np.linspace(1, 10, d.shape[0])
y = np.logspace(0, 1, d.shape[1])

fg = figure()
ax = fg.gca()

ax.pcolormesh(x, y, d)
ax.set_yscale('log')
ax.set_ylim(y[0], y[-1])

ax.set_xlabel('x')
ax.set_ylabel('y')

show()

Matlab

2-D line plot:

x = logspace(0, 10, 100);
y = log(x).^2;

fg = figure();
ax = axes(fg);

plot(ax, x, y);
ax.XScale = 'log';

xlabel(ax, 'x');
ylabel(ax, 'y');

pseudocolor pcolor(): observe the stretching of the ticks along the y-axis. In some cases it’s helpful to set the axis limits manually to avoid whitespace past the last data point.

d = rand(10, 10);
x = linspace(1, 10, size(d, 1));
y = logspace(0, 1, size(d, 2));

fg = figure();
ax = axes(fg);

pcolor(ax, x, y, d);
ax.YScale = 'log';

xlabel(ax, 'x');
ylabel(ax, 'y');

If one suspects a website has been compromised, don’t use a standard web browser to access the site as there could be zero-day malware on the site. Consider Terminal programs that don’t have JavaScript enabled like curl or lynx if necessary to browse the site, preferably from a VM or other isolated computing resource. These programs are also not immune from security vulnerabilities.

DNSViz helps visualize the DNS chain. Keep in mind DNS and nameserver updates can take minutes to hours to propagate.

macOS:

dscacheutil -q host -a name host.invalid

Linux / macOS / WSL:

dig +trace host.invalid

If the DNS entries seem valid, consider that the web hosting server (that sends the HTML files to browser) may be compromised.

Matlab Compiler compiles existing .m Matlab script to run as an executable on another PC without Matlab. Matlab Compiler Runtime MCR is used on computers that don’t have Matlab to run the compiled Matlab code.

Caveats:

• Matlab Compiler does not in general speedup Matlab code execution
• in general, compiled binaries might be disassembled to reverse-engineer the underlying code
• MCR version on each computer running the executable must match the Matlab version of the compiling Matlab, and the compiling computer must have the same operating system as the MCR running computers.

Compiling computer: ensure Matlab Compiler is installed:

assert(license('test', 'compiler') == 1)

Example program “mymcc.m”:

function Y = mymcc()

X = 0:0.01:2*3.14;
Y = sin(X);
plot(X,Y)
title('Test of MCR')
xlabel('x')
ylabel('y')
disp('I ran an MCR program!')

end

Compile “.m” file in Matlab:

mcc -m -v mymcc.m

Run compiled Matlab program:

./run_mymcc.sh mymcc

I ran an MCR program!

and show a Matlab plot window showing a sine wave. Close the plot window to end the execution of your program.

Notes:

Reference

GNU Octave does not currently have the ability to compile “.m” files. Octave mkoctfile is to distribute C / C++ code that calls Octave functions–and ABI-compatible Octave must be installed on the user computers

There can be substantial speed boosts from Intel compilers with Intel CPUs. Intel oneAPI gives advanced debuggers and performance measurements. Intel oneMKL can give a significant speed boost to ABI-compatible compilers for certain math operations.

For Windows, use the oneAPI Command Prompt. Otherwise, specify environment variables CC, CXX, FC to indicate desired compilers via script:

Build with CMake:

cmake -B build

cmake --build build

Example CMakeLists.txt

To see the compiler commands CMake is issuing, use

cmake --build build -v

Refer to Intel Link Advisor for supported compiler / operating system / MKL combinations.

Get runtime confirmation that MKL is being used via MKL_VERBOSE.

• Linux:

  MKL_VERBOSE=1 ./mytest

• Windows

  set MKL_VERBOSE=1
  mytest.exe

That gives verbose text output upon use of MKL functions. That runtime option does slow down MKL performance, so normally we don’t use it.

HDF5 is a popular data container format, a filesystem within a file. Many programs supporting HDF5 like Matlab can read and plot data. It is useful to have a standalone simple data browser like HDFview.

HDFview from the HDF Group can read HDF5, NetCDF4, and FITS. HDFview enables editing (writing) as well as reading HDF5. One can simply download the HDFview binaries, or use package managers:

• Linux: apt install hdfview
• macOS: brew install hdfview

ViTables is a Python-based HDF5 GUI.

The Java-based PanoplyJ is available for macOS, Linux and Windows.

To ensure the user set compile flags take precedence by appearing later in the command line vs. CMake’s automatic flags, use add_compile_options to set language-specific or project-wide compiler options. target_compile_options is similar, but applies to only one target.

The generator expression $<$<COMPILE_LANGUAGE:C>:...> is used to only add the flag for the C language. This is important as many compiler options are language-specific, particularly for C / C++ and Fortran projects.

If one truly needs to wipe out all CMake automatic flags, try settingCMAKE_FLAGS variable to an empty string.

Git uses the EDITOR environment variable to determine which text editor to use for commit messages. Since the commit message editing is typically small and simple, it may be desired to set a distinct text editor just for Git. This is done via Git global config:

git config --global core.editor "nano"

Most environment variable have alphanumeric names and don’t need any special consideration to access. On Windows, some important programs still use the “Program Files (x86)” directory, denoted by environment variable “ProgramFiles(x86)”.

cmake_minimum_required(VERSION 3.10)

set(px $ENV{ProgramFiles\(x86\)})

message(STATUS "${px}")

Most other code languages don’t have any particular issues using environment variables named with special characters.

All of the following print like:

C:\Program Files (x86)

Matlab:

getenv("ProgramFiles(x86)")

Python:

python -c "import os; print(os.environ['ProgramFiles(x86)'])"

C++:

#include <cstdlib>
#include <iostream>

int main()
{
    std::cout << std::getenv("ProgramFiles(x86)") << "\n";
    return EXIT_SUCCESS;
}

Fortran:

program env

implicit none

integer :: i
character(100) :: path

call get_environment_variable('ProgramFiles(x86)', path, status=i)
if (i/=0) error stop "env var ProgramFiles(x86) not found"

print '(a)', path

end program env