J&+ language and applications

This is the home page of J&+ ("with J added", "J plus", or J+) language and YACTS (yet another continuous time simulator) application, based on J+.

J+ is a functional non-imperative simulation language with lazy evaluation, based on J programming language, a dialect of APL. A program in J+ is a collection of (possibly functional) J assignment statements just like a set of formulae on a sheet of paper. The interpreter, implemented as a software library, knows the interdependencies between these formulae and is able to compute any of the defined quantities with minimal effort, keeping track of the values, which were already computed. The driver program (such as YACTS) may ask the interpreter to compute certain quantities and set the values for others (propagating the changes to dependents).

YACTS uses J+ to interpret scripts, defining systems of ordinary differential equations, which it solves. It defines a number of J verbs, which are essential for numerical computing. Please see the online version of YACTS manual page for more information, including a more detailed introduction to J+ language.

The current flagship application of YACTS is the Landau-Lifhitz-Gilbert equation (LLG) solver. This is real application with performance, comparable to LLG solvers, expressed as thousands of lines of C++ code. In a few dozen (of non-comment) lines it contains both simulation (including the definition of vector cross-product) and visualization (able to plot pretty Line Integral Convolution vector fields, superimposed on a color map of local energy). Please see README file in the "examples" sub-directory of J+ distribution for instructions how to run it. The LLG solver was the original motivating application for writing YACTS and J+, but the resulting system is certainly capable of doing much more.

The strong point of YACTS scripts is that they are self-contained and terse (thanks to usage of J !). They are comparable in information density to mathematical formulae. Look, for example, at the 7 lines, expressing the stray fields of rectangular prism (verb hp in llg script) and formula (1) in the classical work by A. Aharoni [J. Appl. Phys. 83(6), 1998, p. 3432]. Note that (1) expresses only one component of the field at a single point, while hp evaluates all three, in arbitrary number of locations at the same time. Also, unlike (1), hp is much more formal and can be directly evaluated by computer. It is not hard to imagine that J+ scripts can be publishable in scientific journals directly (e.g. in an Appendix), providing the reader with the value of seeing exactly how the particular result was computed.

Internally J+ library consists of several levels. The first level (classes jarray, jengine) defines direct interface between J and C++, providing the caller with ability to execute J sentences, directly working with J arrays (in a type-safe manner as facilitated by jarray_of_type template), define J verbs and adverbs as C++ functions. The second layer is jplus class, built on top of jengine. It parses and executes J+ scripts with methods to request and set values of variables, defined therein. The third layer is yacts class, built on top of J+, which adds meaning to a few specific variables, defines the library functions for numerical computation and visualization, solves the ODE, manages the trajectory file (class trjfile) and provides options for parallel processing (e.g. on a cluster) of the computed trajectory.

Release notes

Portability release 0.4.6 brings YACTS to 64-bit Linux and Windows.

See the NEWS file in the source distribution for more details and version history.

The current release of YACTS is of alpha quality (but it does solve LLG well !). The internal interfaces are more or less well-defined, though. These are worth looking at and commenting. The implementation is ugly (and in some places very ugly). There is a rudimentary testsuite, containing slightly more than 100 tests. Having the testsuite around will help to rewrite the ugly parts in future. The weakest point at the moment is error handling and reporting. User errors mostly cause assertions to fail and YACTS to exit. The error handling must definitely be improved.

Portability: YACTS uses GNU autoconf and should, in theory, be portable. It was successfully compiled on 32/64 bit Ubuntu 12.04, and cross-compiled for Win32/Win64 in Ubuntu 12.04 using MXE [http://mxe.cc].

Dependencies: YACTS depends on a number of external libraries to do its job, on Ubuntu Linux the required build dependencies can be installed with the following command:

apt-get install lynx g++ libc6-dev make \
        autoconf automake libltdl-dev libtool libatlas-base-dev \
        libsundials-serial-dev libfftw3-dev libreadline-dev \
        txt2man doxygen graphviz man2html

Some of these (like readline or txt2man) can be missing, which will automatically turn off some of the features (not recommended). In MXE one needs to install the following packages: gcc readline libltdl fftw sundials. On other platforms try the equivalents. Please see the INSTALL file for more details.

Binary versions of YACTS for Windows are available here.

License: YACTS is released under the terms of GNU General Public License, which is compatible to the licenses of all the external code it uses.

Download

Binaries:
Static binaries for Windows: are here.

Source:
version 0.4.6 (13 July 2015), tar.gz, 3457834 bytes, md5: fa0d35d546b033e2ca121f4bfe5b2778.
version 0.4.5 (9 July 2015), tar.gz, 3442268 bytes, md5: 1971f904541cc826cd6466611ac9e818.
version 0.4.4 (15 July 2012), tar.gz, 2964696 bytes, md5: 41463f40a1423f62f86be430fda13ea8.
version 0.4.3 (29 June 2012), tar.gz, 2964919 bytes, md5: 5e10bebdfa2c037df98a9edd5bf319e1.
version 0.4.2 (27 June 2012), tar.gz, 2938950 bytes, md5: 54d5bf8fb7419398f362f359c13603c3.
version 0.4.1 (25 June 2012), tar.gz, 2917162 bytes, md5: 226fd41851842b9db0544816164fa37a.