Scientific Computing

The Radio Shack 21-940A mag mount 27 MHz CB antenna spanned over two decades of sales with a well-performing, economical design. A trunk-mount variant 21-908A is said to have been featured on the “Dukes of Hazzard” program, which has led to abnormally high valuation even for well-used examples. The 21-940A mag mount is only capable of 25 watts transmit power and can easily permanently burn out with common 10 meter mobile transmit power. The coil is shunt wound, meaning it normally reads as a short from center pin of the UHF connector to shield (ground). The SWR is under 1.5:1 across the 26.965 - 27.405 MHz CB band, and is usable over about 1.2 MHz of total bandwidth. The antenna is just over 1 meter tall and performs similarly to the modern Wilson Little Wil, Tram 300, and similar - except these antennas are generally well capable of the transmit power of a typical 10 meter mobile radio, while the 21-940A is not.

Xarray can write and load netCDF4 files into datasets. Warning messages may appear when using older netCDF4 files with newer versions of Xarray or NumPy like:

RuntimeWarning: numpy.ndarray size changed, may indicate binary incompatibility. Expected 16 from C header, got 96 from PyObject

This may indicate underlying incompatibilities between the versions of Xarray, Pandas, NumPy, and the netCDF4 library.

Advantages of conda over pip include:

• distributing per-platform optimized libraries
• prioritized channels resolve version conflicts, helping mitigate Python package dependency hell

Conda channel priority order is ordered by which channel appears first (highest) in .condarc. We generally recommend adding per-environment channels rather than modifying the global configuration to avoid corrupting multiple environments with incompatible packages`.

In general “strict” channel priority is recommended to mitigate compatibility problems.

conda config --set channel_priority strict

conda config --get channel_priority

Add a conda per-environment channel:

conda activate <env-name>

conda config --env --add channels <channel-name>

Get the current channel list for an environment:

conda activate <env-name>

conda config --env --show channels

Like the Numpy helper function numpy.testing.assert_allclose(), the Xarray helper function xarray.testing module compares floating point arrays within a specified tolerance. Example:

import xarray
import xarray.testing

# code under test
dat = myfunc(...)

# load the reference Dataset to compare against
ref = xarray.open_dataset("ref.nc")

xarray.testing.assert_allclose(ref, dat)

dat.equals(ref) is generally inappropriate to directly compare floating point numbers. Clive Moler’s article address the topic of floating point comparisons succinctly.

Floating point comparison algorithm: across computing languages, an algorithm suitable for comparing floating point numbers “actual, desired” to absolute tolerance “atol” and relative tolerance “rtol” is:

isclose = abs(actual - desired) <= max(rtol * max(abs(actual), abs(desired)), atol)

isclose is boolean True or False – an array if actual or desired are arrays.

Projects using GCC, G++, and Gfortran compilers often set the -Wall option as default. The intent of -Wall is to enable a common subset of warnings that are generally useful for catching potential issues in your code. However, new warnings may be buggy to the point of breaking builds on valid code, or cause false warnings. It may be beneficial to not enable -Wall by default for end-user builds, but only for development builds.

GCC does not appear to have a way to tell what warnings are enabled by -Wall programmatically. Instead, one must refer to the GCC documentation or even the GCC source code to see which warning flags are included in -Wall. For example, in Gfortran 15.1, the -Wall option includes the -Wexternal-argument-mismatch warning, which was broke builds on valid code, and was fixed in Gfortran 15.2.

Gfortran 15.1 has a bug with the -Wexternal-argument-mismatch flag. This flag is implicitly included in the -Wall option. In Gfortran 15.1–fixed in Gfortran 15.2–the -Wexternal-argument-mismatch warning causes compilation to fail on correct code. To work around this bug, suggest in the build system such as CMake to detect GCC 15.1 and disable the -Wexternal-argument-mismatch warning. It’s also relevant to consider if -Wall is a flag one wants to automatically set for the default end-user build, as such a bug could happen for future versions of GCC as well.

In CMake, detect GCC 15.1 and disable the problem flag:

if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU" AND
   CMAKE_Fortran_COMPILER_VERSION VERSION_GREATER_EQUAL "15.0" AND
   CMAKE_Fortran_COMPILER_VERSION VERSION_LESS "15.2"
   )
  add_compile_options($<$<COMPILE_LANGUAGE:Fortran>:-Wno-external-argument-mismatch>)
endif()

Fortran bind(C) allows Fortran to call C functions and vice versa. However, Fortran arrays are one-based by default, while C arrays are zero-based. This can lead to confusion when passing arrays between Fortran and C. Adding to the confusion is multiple GCC Gfortran versions have known bugs that were not fixed as of their final release.

Specifically, the versions of Gfortran known to be working correctly are Gfortran ≤ 8.5 and Gfortran ≥ 12. Known broken GFortran versions are 9.x, 10.x, 11.x.

We show this by example:

program test_bounds
use iso_fortran_env, only : error_unit
implicit none

real, allocatable :: a(:)
integer :: L1,L2, U1,U2
allocate(a(1:2))

L1 = lbound(a,1)
U1 = ubound(a,1)

call c_bounder(a)

L2 = lbound(a,1)
U2 = ubound(a,1)

if (L1 /= L2 .or. U1 /= U2) then
  write(error_unit, '(a,2i2,a,2i2)') 'FAIL: bounds changed before/after lower:', L1,L2, " upper: ", U1,U2
  error stop
endif

print '(a)', "bounds check OK"

contains

subroutine c_bounder(a) bind(c)
real,  intent(inout) :: a(:)
end subroutine c_bounder

end program

Some code may have integer declarations like u_int, u_long, etc. These types are not part of the C or C++ standard and may not be portable across different platforms. Instead, it’s recommended to use the standard integer types, including those defined in <stdint.h> (C) or <cstdint> (C++). For example, replace “u_int” with unsigned int or a fixed-width type appropriate for the use case. “u_int” is from header <sys/types.h> and is not part of the C standard, and it may not be available on systems like Windows.

GDB debug program can be installed on macOS via Homebrew. GDB on macOS with ARM64 Apple Silicon requires code signing as described in the Homebrew gdb formula page.

Without code signing, GDB on Apple Silicon for local executables doesn’t work:

gdb ./myexe

r

❌️ Don’t know how to run. Try “help target”.

Alternative: use a virtual machine with Linux for ARM64 to run GDB within the VM as usual for a Linux machine.

Reference: Homebrew commit adding Apple Silicon support for GDB.

The Mathworks experienced a major outage starting on May 18, 2025 due to a ransomware attack. The Mathworks’ license servers have been effectively required by default for Matlab for ~ five years. Virtually all Mathworks services were down initially for about a week, and then services are gradually being restored. The outage affects users worldwide regarding ability to start Matlab or install toolboxes. Trying to access Mathworks services results in a 503 return code or “no healthy upstream” or similar. External institutions cited a cyberattack.

Internet discussions have been peppered with recommendations to switch to GNU Octave, which is a free and open-source alternative to Matlab. However, the proprietary toolboxes that add so much value and functionality to Matlab are often not available for GNU Octave. Examine the GNU Octave Help forum to assess issues facing Octave users vs. Matlab Answers forum. It behooves instructors to consider avoiding proprietary toolboxes except where essential to the learning goals. Note that Python packages (and libraries in just about every programming language) have also experienced cyberattacks. Matlab adds serious value to many research and development projects, but the reliance on a single vendor for such a critical tool is a risk that should be considered.

Transitioning to open-source alternatives like GNU Octave or Python take considerable effort. Using the Matlab Engine for Python can help incrementally transition Matlab projects to Python.