GluCat: Clifford algebra templates / News: Recent posts

GluCat 0.12.1 works with current compilers such as g++ 13.2.0, clang++ 18.1.3,
and icpx 2024.2.1, as well as Python 3.12.3 and Cython 3.0.8.

The configuration option
./configure --with-eig=bindings
has been deprecated and will be removed in future versions.

The configuration options that are deprecated in GluCat 0.10.1 have been removed in GluCat 0.11.0. The comprehensive regression tests now test for 10 different combinations of configuration options, rather than the 15 different combinations tested previously.

The following configuration options are deprecated as of GluCat 0.10.1 and will be removed in future releases. See INSTALL for details.

  --enable-check-isnan    check for NaN values at various places in the code
  --with-stdlib[=ARG]     C++ standard library to use (libcxx|libstdcxx)
  --with-map[=ARG]        type of map to use (map|stdunordered)
  --with-dense-mat        use dense matrices
  --with-random[=ARG]     type of random number generator to use (std|gsl)
  --with-pool-alloc       use Boost Pool allocator

GluCat 0.10.0 introduces a change in the way that the headers are to be used. Instead of

#include "glucat/glucat.h"
#include "my_tuning.h"
#include "glucat/glucat_imp.h"

with my_tuning.h containing a definition of Tune_P, the tuning policy class, you are expected to use

#include "glucat/glucat.h"
#include "glucat/glucat_imp.h"
#include "my_tuning.h"

with my_tuning.h containing a definition of the tuning policy class that you are using as a template parameter. See README for details.... read more

GluCat 0.9.0 introduces some changes that improve usability of the results, but produce bit-for-bit different output when compared to previous versions.

• Promotion of ScalarT now increases the number of floating point mantissa bits on all tested architectures, including ARM v8. Demotion is the reverse.

• The default limit for the truncated() member function is now std::numericlimits<ScalarT>::epsilon().... read more

2021-10-06: 0.8.5

The GluCat headers compile with recent Clang, GCC and Intel C++ compilers, but are mostly unchanged. The ./configure script has been restructured to provide better support for configuration options and compiler differences. The PyClical plotting demo has been updated to support more recent versions

2020-07-12: 0.8.4
PyClical has now been ported to Python 3, and can no longer be used with Python 2. The PyClical classes are unchanged except that the constructors
now use Python 3 default Unicode strings rather than Python 2 byte strings. The C++ code is essentially unchanged.

See INSTALL and README for details.

2020-05-13: 0.8.3

GluCat 0.8.3 builds with current versions of Clang, GCC and Intel compilers, Boost, Cython and Python. The source code is otherwise unchanged.

See INSTALL for details.

2016-07-06: 0.8.2:
The GluCat classes basis_matrix_t and framed_multi<> have been refined.

The class basis_matrix_t is now based on int rather than on Scalar_T. This
should make basis matrix generation more efficient, especially when Scalar_T
is of class dd_real or qd_real.

The class framed_multi<> is now based on either map<index_set_t, scalar_t=""> or
unordered_map<index_set_t, scalar_t="">, rather than the previous base class,
map<const index_set_t,="" scalar_t=""> or unordered_map<const index_set_t,="" scalar_t="">.
This is for compatibility with the libc++ implementations of these bases
classes.... read more</const></const></index_set_t,></index_set_t,>

I have updated glucat-0.8.1.tar.gz to include 4 recent commits that fix problems with make dist and make install. Please download glucat-0.8.1.tar.gz again if you downloaded before today (5 May).

Paul Leopardi committed [d9f624]

Try to repair more Makefile.am files
2 hours ago
Paul Leopardi committed [7b214b]

glucat-DESTDIR.patch provided by Atri Bhattacha...
2 hours ago
Paul Leopardi committed [420a1d]... read more

The configuration option --with-tuning=arg controls test tuning via preprocessor
macros and the header files test/tuning.h and test/undefine.h.

The configuration option --enable-check-isnan controls checks for NaN values,
and the configuration option --with-pool-alloc controls the use of the Boost
pool allocator.

The scripts test/test-all-config-options.sh, test/diff-all-config-outputs.sh
and test/copy-all-config-outputs.sh enable comprehensive tesing of configuation
options.... read more

All deprecated options have been removed from the code, along with the code associated with related defined options. Because this is a backwards-incompatible change, the version number has been bumped to 0.8.0.

Specfically, the code can no longer optionally use:
<ext/hash_map> (was enabled by the option _GLUCAT_USE_GNU_CXX_HASH_MAP),
<backward/hash_map> (_GLUCAT_USE_BACKWARD_HASH_MAP),
<tr1/unordered_map> (_GLUCAT_USE_TR1_UNORDERED_MAP),
<tr1/random> (the old default: the option _GLUCAT_USE_STD_RANDOM
is no longer needed, and is ignored, as <random> is now the default),
<alglib/evd.h> (_GLUCAT_USE_ALGLIB) or
<boost/numeric/bindings/lapack/gees.hpp> (_GLUCAT_USE_BINDINGS_V1).

I have created a mirror of the Git repository for GluCat on GitHub at https://github.com/penguian/glucat
Check it out (or clone or fork it)!

What happens when randomness follows a well-defined pattern? What happens when we play a chaos game in a conformal space?
https://www.tumblr.com/search/penguian

For my Pozible project “The Schroedinger Experiment” I used my GluCat and PyClical software with Mayavi to create unique computer artwork for my $32+ supporters. The script plots 3 tori as the orbits of two orthogonal bivectors in 3D conformal geometric algebra, as a simple type of “chaos game.” Once the software had produced each 3D image, I adjusted the view to form a composition, and then saved it to a file at 4095 x 4095 resolution. The thumbnails presented in the gallery are 1/5 size: 819 x 819.... read more

The use of Autotools in configuring, building and installing GluCat and PyClical has been simplified and improved. Deprecated configuation options have been dropped. The default for --with-random is now std. The default for --with-map is now stdunordered.

The file pyclical/PyClical.cpp was missing from glucat-0.7.4.tar.gz.This prevented PyClical from building on systems without Cython. The file pyclical/PyClical.cpp, built with Cython 0.19.1, is now included in the download.

GluCat 0.7.4 optionally improves the precision of the sqrt, log and exp functions.

It does so by implementing constructors that allow mixed precision, e.g. a matrix_multi<float> can be initialized using a framed_multi<double>, etc. The precision of the sqrt(), log() and exp() functions is controlled by the tuning parameter function_precision.</double></float>

GluCat 0.7.3 fixes a bug where the line

print_exec("from PyClical import *")

was left out of some of the pyclical_tutorial*.py files.
The C++ code, Cython code and the configure and Makefiles are unchanged from
GluCat 0.7.2, other than updating the version number, and so these have not been
tested again.

Some of the PyClical tutorials in pyclical/demos are missing the line:

print_exec("from PyClical import *")

This is fixed in Git, and will be fixed in GluCat 0.7.3 to be released shortly.

For details, see
https://sourceforge.net/p/glucat/git/ci/f6be525bda3f7342c561a1e85c8dbb2d0ba09433/

The Pyclical tutorials are now accompanied by corresponding IPython notebooks.

The nork() function in matrix.h and matrix_imp.h that implements the left Kronecker quotient is now accompanied by the signed_perm_nork() function, which is faster for the case used by fast<>() in matrix_mult_imp.h.

Use of the Boost pool allocator with framed_multi<> is now optional, controlled via the new symbol _GLUCAT_USE_BOOST_POOL_ALLOC.... read more

GluCat 0.7.1 fixes a bug which prevented compilation in the case where the class glucat::framed_multi<> is based on std::map.

GluCat 0.7.0 has more accurate sqrt and transcendental functions and includes PyClical tutorials.

The PyClical Python extension module now comes with a set of tutorials that guide you through working with Clifford algebra calculations in Python.

The GluCat library now supports C++11, including <unordered_map> and <random>.

The GluCat library now has transcendental functions that are more accurate when used with higher precision arithmetic. This is accomplished by using different
Pade' approximations according to the numerical precision needed.... read more

GluCat 0.6.0 includes the PyClical extension module for Python.

The PyClical extension module is based on the prototype from GluCat 0.5.0, but includes a much more comprehensive interface to the GluCat classes index_set<> and matrix_multi<>, as Python classes index_set and clifford. The functions and member functions defined in PyClical include doctests.

There are some changes to the clifford_algebra<> API:
o GluCat does not support complex Clifford algebras, so the real() function is now synonymous with scalar() and the imag() function always returns 0.
o New operators lhs | rhs and lhs |= rhs transform lhs by the twisted adjoint action of rhs.
o New member functions, grade() : maximum of the grades of each term; pure() : pure part.
o New function complexifier(val) : square root of -1 which commutes with all members of the frame of the multivector val. The name "elliptic" is now deprecated: use "complexifier" instead.
o New functions sqrt(val,i,prechecked), and log(val,i,prechecked) : square root and logarithm of multivector with specified complexifier.... read more

GluCat 0.5.1 fixes sqrt and transcendental functions:

The sqrt() and log() functions, and functions based on them, such as cos(), acosh(), etc. may give incorrect results when using GluCat 0.5.0 and earlier. This is because the algorithms used in GluCat 0.5.0 and earlier for sqrt(x) and log(x) fail if x is represented as a matrix having a negative real eigenvalue.

This has now been fixed in GluCat 0.5.1, with the aid of external libraries which contain eigenvalue functions.... read more

GluCat now includes PyCliCal: a prototype Python interface to GluCat, implemented via Cython. The included files pyclical/pyclical_demo.py and pyclical/pyclical_demo.out highlight some of its capabilities.

The framed_multi<> and matrix_multi<> classes now also have a new static member function random(frm), which returns a random multivector within the given frame frm, with each coordinate independently distributed according to the standard normal distribution, rescaled by dividing by the square root of the dimension of the frame. The random() function uses either TR1 or GSL normal random numbers, via the random_generator<> class defined in glucat/random.h.... read more