Nelson: Scientific Computing Environment Programming Language.

Nelson is an open-source scientific computing environment designed for numerical analysis, data visualization, and algorithm development.

Nelson provides mathematical functions, structured data types, and visualization tools for numerical computing workflows.

This documentation serves as your complete reference guide to Nelson's built-in functions, module system, and programming capabilities - from basic mathematical operations to advanced computational tasks.

Functions manager provides tools to manage and interact with Nelson's function search path and function types.

It includes commands to add or remove directories from the search path, execute built-in functions, clear built-in functions, evaluate functions, and more.

Utilities are available to check for the existence of built-in, macro, or mex functions.

The Modules Manager in Nelson provides the infrastructure to extend and manage the environment at runtime.

It allows modules to be dynamically added, removed, and queried, making the system flexible and adaptable to different workflows.

With support for both internal and external modules, the manager handles module metadata, paths, and versioning.

It also provides utilities for organizing user-defined toolboxes, managing gateways, and ensuring that dependencies are properly loaded.

This framework simplifies module distribution, integration, and maintenance, forming the backbone of Nelson’s modular architecture.

The Core module provides the fundamental building blocks of the Nelson environment.

It includes essential services for program execution, environment management, and system interaction.

Through this module, users can evaluate code dynamically, manage execution flow, query program state, and access key system information such as versioning, configuration, and licensing.

It also offers basic utilities for file identification, checksums, cryptography (the crypto namespace: hashes, HMAC, Ed25519 and X25519, Argon2, authenticated encryption and secure random), and terminal capabilities.

Together, these features form the foundation upon which all other modules and user-level functionality in Nelson are built.

The Engine module manages the execution environment of Nelson itself.

It provides mechanisms to handle program startup and shutdown behavior, command-line integration, and runtime modes.

This includes support for user-defined initialization and termination scripts, platform-specific system requirements, and interpreter directives for cross-platform script execution.

It serves as the core interface between Nelson and the underlying operating system, ensuring flexible configuration and smooth control over how the software is launched and operated.

The Interpreter Functions module provides the core language constructs and control mechanisms that define the execution flow in Nelson.

It includes essential elements such as loops, conditional branching, error handling, and function declarations.

The module also offers tools for parsing and analyzing code, working with keywords, and managing recursion limits.

Together, these features establish the fundamental syntax and semantics of the Nelson language, enabling users to write structured, dynamic, and reliable programs.

The Error Manager module provides the mechanisms for handling errors and warnings in Nelson.

It defines how exceptions are created, raised, and rethrown, as well as how diagnostic information can be retrieved after an error or warning occurs.

It lets programs control execution after failures, capture diagnostic reports, and display warnings without stopping execution.

It provides the common error and warning primitives used by Nelson code.

The Console module manages interaction with Nelson’s command window.

It provides tools to control the display, handle user input, and query terminal properties.

These features allow scripts and applications to communicate directly with the user through the console, making it easier to build interactive workflows and adapt output to the current terminal environment.

The Text completion module provides completion candidates for Nelson command lines, editors, and terminals.

The Display Format module defines how values, variables, and expressions are presented in Nelson.

It offers control over numeric formatting, text representation, and the way results are shown in the console.

The module also provides mechanisms for capturing formatted output programmatically, enabling both human-readable display and programmatic handling of results.

This ensures flexibility in how information is presented and reused within scripts and applications.

The Characters Encoding module provides tools for converting between native byte representations and Unicode characters.

It enables scripts to correctly interpret and manipulate text in various encodings, ensuring compatibility across different platforms and locales.

The module also detects character sets that match a given input for text processing and internationalization.

The Localization module manages language settings and internationalization in Nelson.

It provides mechanisms to query available languages, determine the current and default language, and change the interface language dynamically.

This module adapts Nelson to linguistic and regional settings and supports multilingual interfaces.

The i18n module provides tools for internationalization and localization of text within Nelson.

It retrieves translated strings for the current locale, provides utilities for translation workflows, and generates translation file headers.

This module helps developers create software that can adapt dynamically to multiple languages and cultural contexts.

The Types module provides tools for managing and inspecting data types in Nelson.

It provides functions to query variable types, distinguish numeric, logical, string, and object values, and work with specialized types such as sparse or integer arrays.

The module also supports creation of objects and validation of variable names, helping ensure type safety and consistency across scripts and functions.

For C++ extension and embedding code, see C++ value API.

The Logical Type module provides tools for working with Boolean values and logical operations in Nelson.

It enables the creation, conversion, and manipulation of logical data, supporting fundamental logical operations that are essential for control flow, conditional evaluation, and decision-making in scripts and programs.

The Single Type module provides tools for handling single-precision numeric values in Nelson.

It enables conversion of variables to single-precision format, allowing efficient storage and computation while maintaining sufficient numeric accuracy for many applications.

The Double Type module provides tools for handling double-precision numeric values in Nelson.

It enables conversion to double precision and offers access to key numeric limits, supporting high-accuracy computations and reliable handling of large or small floating-point numbers in mathematical and scientific applications.

The Integer Types module provides tools for working with signed and unsigned integers of various sizes in Nelson.

These types are particularly useful for efficiently storing and processing large datasets, such as images or large numeric arrays.

The module supports conversions between integer formats and provides access to the minimum and maximum values representable for each integer type, ensuring safe and precise integer arithmetic.

The Sparse Type module provides tools for creating and manipulating sparse matrices in Nelson.

It supports efficient storage and computation for matrices with a large number of zero elements, including conversion between sparse and full representations, generation of special sparse matrices, and access to nonzero elements.

This module enables memory-efficient handling of large datasets and optimized numerical operations on sparse structures.

The String Type module provides functions for creating, manipulating, and analyzing text in Nelson.

It supports conversion between character arrays and string arrays, concatenation, trimming, justification, and case conversion.

The module also includes functions for searching, matching, replacing, and formatting strings, enabling flexible text processing for both simple and complex string operations.

The Function Handle Type module provides tools for creating and managing function handles in Nelson.

It supports anonymous functions, conversion between strings and function handles, and verification of function handle objects.

This module enables flexible and dynamic function invocation, allowing functions to be passed, stored, and executed programmatically.

The Handle module provides tools for creating and manipulating handle objects in Nelson.

Handle objects are lightweight references to larger data structures, enabling efficient memory management and data sharing between different parts of a program.

This module includes functions for creating, copying, and destroying handle objects, as well as for managing their lifetimes and ensuring proper cleanup.

It also includes classdef reflection, event, listener, dynamic property, weak reference, and typed invalid handle helpers.

The Data Structures module provides tools for creating, manipulating, and inspecting arrays, cells, and structures in Nelson.

It enables conversion between different data formats, access and modification of fields, application of functions to array elements, and organization of structured data.

This module handles complex data through programmatic operations and dynamic data management.

The Dictionary module provides tools for working with key-value mappings in Nelson.

It supports creation and configuration of dictionaries with defined key and value types, querying and modifying entries, and managing the overall structure.

This module enables efficient storage, retrieval, and manipulation of data indexed by unique keys, making it ideal for associative arrays, lookups, and dynamic data management.

The Tables module provides tools for creating, accessing, and manipulating tabular data in Nelson.

Tables are array-like structures with named variables (columns), each capable of holding different data types.

Table metadata is available through T.Properties, and helper functions are provided for adding, moving, renaming, removing and summarizing variables.

Timetables store tabular variables together with row times and provide time-based sorting, retiming, synchronization, and range queries.

The Categorical module provides arrays whose elements belong to a fixed set of text categories.

The Overloading module provides mechanisms for customizing the behavior of functions and operators in Nelson.

It defines how standard operations or built-in functions behave when applied to user-defined types or objects.

This capability enables the extension of Nelson’s language features, supporting more natural and expressive use of custom data structures.

The Operators module provides tools for performing arithmetic, logical, relational, and array operations in Nelson.

It supports element-wise and matrix computations, concatenation, subscripted referencing and assignment, and short-circuit logical operations.

This module enables flexible manipulation of data structures and numerical arrays, forming the foundation for both basic calculations and advanced mathematical expressions.

The Constructors module provides tools for creating fundamental numeric values, scalars, vectors, and matrices in Nelson.

It includes constants, identity and diagonal matrices, and special values such as infinity, NaN, and machine precision.

This module forms the basis for initializing data structures and performing mathematical and numerical computations.

The Elementary Functions module provides fundamental mathematical operations and matrix manipulations in Nelson.

It includes numeric computations, array and matrix operations, complex number handling, rounding and scaling, and various utility functions for querying properties of arrays and matrices.

The module also supports construction of special matrices, grids, and sequences, enabling robust and efficient implementation of mathematical algorithms and numerical analyses.

The Trigonometric Functions module provides functions for trigonometric calculations in Nelson.

It includes standard trigonometric functions such as sine, cosine, and tangent, as well as their inverses and hyperbolic counterparts. The module supports angle measurements in both degrees and radians, allowing for flexible computations based on user preferences.

The module also provides utilities for converting between degrees and radians in mathematical and engineering calculations.

The Special Functions module provides tools for performing advanced mathematical operations in Nelson.

It includes functions for statistical distributions, combinatorial calculations, and other specialized mathematical computations that are essential in various scientific and engineering applications.

This module enhances Nelson's capabilities by offering a range of functions that support complex analyses and modeling tasks.

The Linear Algebra module provides matrix and vector computation functions in Nelson.

It includes functions for matrix factorization, decomposition, inversion, and analysis, as well as operations on eigenvalues, singular values, and subspaces.

The module includes numerical methods for evaluating matrix properties, condition numbers, and transformations used in linear algebra problems.

The Statistics module provides tools for analyzing and summarizing data in Nelson.

It includes functions for computing measures of central tendency, variability, correlation, and probability distributions.

The module also supports advanced data summarization structures for accurate quantile estimation, enabling robust statistical analysis and interpretation of datasets.

The Data Analysis module provides tools for performing numerical and array-based analyses in Nelson.

It supports cumulative operations, sorting, aggregation, convolution, and identification of unique or missing values.

This module supports processing, summarization, and exploration of datasets for computational and analytical tasks.

The ODE Solvers module provides time integration functions for explicit, stiff, and implicit differential equation workflows in Nelson.

It includes solver entry points, delay and boundary value problem wrappers, option handling, interpolation, solution extension, event detection, and object-oriented problem definitions.

When the optional SUNDIALS backend is built, the object workflow can also select CVODES and IDAS solver values.

The module is designed for numerical experiments, simulations, and teaching examples that need compact solver setup and reproducible result objects.

Tutorial pages cover solver choice, events, tolerances, mass matrices, implicit equations, delay equations, boundary value problems, interpolation, extension, object workflows, and complex states.

The Polynomials module provides tools for creating, manipulating, and analyzing polynomials in Nelson.

It supports polynomial evaluation, differentiation, integration, fitting, root finding, and matrix polynomial operations.

This module enables efficient handling of polynomial expressions for mathematical modeling, curve fitting, and numerical analysis.

The Geometry module provides tools for performing geometric transformations and computations in Nelson.

It supports rotation operations in three-dimensional space, convex hulls, Delaunay triangulations, Voronoi diagrams, spatial searches, and scattered data interpolation.

This module is useful for applications in computer graphics, robotics, computational geometry, interpolation, and spatial analysis.

The Control System module provides algorithms and tools for designing, analyzing, and tuning linear control systems in Nelson.

It supports state-space and transfer function models, system transformations between continuous and discrete time, and computation of poles, zeros, and frequency responses.

The module also includes system balancing, controllability and observability analysis, regulator and estimator design, and simulation of dynamic responses.

These tools are used to model, analyze, and control linear dynamic systems in engineering and research code.

The SLICOT module provides advanced numerical algorithms for computations in systems and control theory.

It includes tools for matrix factorization, system balancing, stability analysis, pole assignment, and solutions of Lyapunov, Riccati, and Sylvester equations.

The module supports both continuous- and discrete-time systems, including descriptor and multi-input systems, enabling precise and efficient analysis, design, and control of complex dynamic systems.

The Signal Processing module provides tools for analyzing, filtering, transforming, and resampling sampled signals in Nelson.

It includes windowing functions, FIR and IIR filter design, digital filtering, zero-pole and second-order-section conversions, cross-correlation, and conversions between magnitude, power, and decibel representations.

The module also supports multirate processing, spectral estimation, time-frequency analysis, waveform generation, and common signal measurements.

The FFTW module provides tools for computing fast Fourier transforms in Nelson.

It supports one-dimensional, two-dimensional, and multidimensional transforms, as well as inverse transforms and frequency-domain manipulations.

The module enables efficient spectral analysis and signal processing, leveraging high-performance algorithms for both real and complex data.

The Random module provides tools for generating random numbers and random sequences in Nelson.

It supports uniform and normal distributions, random integer generation, permutations, and control over the random number generator state.

This module is essential for simulations, probabilistic modeling, and stochastic computations.

The OS Functions module provides tools for interacting with the operating system in Nelson.

It includes functions for querying system information, managing environment variables, executing shell commands, generating GUIDs, and performing platform-specific operations.

This module lets Nelson scripts interact with the operating system on Windows, macOS, and Linux/Unix platforms.

The File and Folder Functions module provides tools for managing files, directories, and paths in Nelson.

This module supports navigation of the file system, creation and removal of files and directories, querying file and folder properties, building and resolving paths, and handling platform-specific separators.

This module enables efficient and cross-platform file system operations within Nelson scripts and applications.

The File Archiver module provides tools for compressing and decompressing files in Nelson.

It supports creation of zip archives and extraction of files from zip archives, enabling efficient file storage, sharing, and management.

The Memory Manager module provides tools for managing variables and memory in Nelson.

It supports variable creation, assignment, querying, and removal across different scopes, as well as handling global and persistent variables.

The module also supports memory inspection, variable locking, and listing of workspace contents for controlled memory usage in scripts and applications.

The Time Functions module provides tools for working with dates, times, and durations in Nelson.

It supports querying the current time, measuring elapsed time, performing calculations on dates and times, converting between different time representations, and handling calendar-specific operations such as leap years and month-end calculations.

This module enables precise time management, scheduling, and performance measurement in scripts and applications.

The Stream Manager module provides tools for managing input and output streams in Nelson.

It supports reading and writing text and binary data to files, handling file positions, detecting end-of-file conditions, and managing file errors.

The module also supports session logging and workspace load/save operations for controlled file I/O in scripts and applications.

The HDF5 module provides support for working with Hierarchical Data Format (HDF5) files in Nelson.

It creates datasets, reads and writes data and attributes, and inspects file contents.

In addition to standard HDF5 support, it includes utilities for Nelson's native .nh5 format, enabling users to save, load, and inspect workspace variables efficiently.

This module is essential for managing large, structured, and portable scientific data.

The MATIO module reads and writes MAT-files, a format used by several numerical computing environments for storing numerical data.

It enables Nelson to check MAT-file validity, load and save workspace variables, and inspect file contents.

This module supports data exchange between Nelson and MAT-file-compatible environments in scientific and engineering workflows.

The XML module provides functions to create, convert, and manage XML documents for Nelson.

The JSON module provides functions to encode, decode, and format JSON data, allowing easy exchange of structured information between Nelson and external systems.

JSON (JavaScript Object Notation) is a lightweight, text-based data format widely used for transmitting attribute-value pairs and arrays.

This module enables Nelson to interoperate with web services, configuration files, and applications that rely on JSON.

The Parquet module provides local file support for Apache Parquet data sets.

It reads and writes column-oriented tables, exposes file metadata, and provides datastore and row-filter helpers for workflows that process one or more Parquet files.

Supported table variables include logical values, integer types, single and double precision floating point values, text, datetime values, duration values, nested tables stored as struct columns, and homogeneous primitive cell vectors stored as list columns.

The Spreadsheet module provides functions for reading and writing tabular data from and to text-based spreadsheet formats, such as CSV and delimiter-separated files.

It supports importing into various data types like numeric arrays, cell arrays, and tables, as well as exporting them back to files.

This enables smooth interaction with spreadsheet software (Excel, LibreOffice Calc, etc.) and data exchange between applications.

In the world of parallel computing, the Message Passing Interface (MPI) is the de facto standard for implementing programs on multiple processors.

This module provides functions to initialize, manage, and finalize MPI environments, as well as to perform communication between processes, both point-to-point and collective.

It enables Nelson programs to run efficiently on distributed-memory systems and clusters.

Note: MPI support is not available on Windows on ARM64 (woa64) architecture.

The parallel module provides tools for running computations asynchronously in the background, managing task scheduling, and retrieving results.

It enables Nelson programs to execute functions concurrently, improving efficiency and responsiveness by offloading work to background workers.

The ipc module provides basic tools for interacting with processes and enabling communication between them.

It allows retrieving process identifiers and using a communicator object for exchanging information across Nelson processes.

The audio module provides functions for reading, writing, analyzing, and playing audio files.

It supports playback control through the audioplayer object, manipulation of playback properties, and metadata handling.

It also includes utilities for signal conversion and sound generation.

The History Manager module in Nelson provides tools to access and manage the command history of your session.

It records previously executed commands, recalls them for reuse, and keeps command history organized.

The GUI module provides functions to create and interact with graphical user interface components, dialogs, and application windows.

The QML Engine module allows Nelson programs to display, manipulate, and interact with graphical content using Qt's QML framework.

It provides functions to manage QML components, access Qt objects, and integrate JavaScript and QML logic.

The Text Editor module provides an embedded Nelson editor for creating, editing, and formatting Nelson scripts and files.

The graphics module provides functions for creating, customizing, and managing plots, figures, colormaps, and graphical objects.

It includes 2-D and 3-D visualization, user interaction tools (zoom, pan, rotate), and utilities for working with colors, legends, axes, and text annotations.

The Graphics I/O module provides functions for importing, exporting, and managing graphical content and image formats.

It supports reading and writing image files, copying figures, and saving plots in various file formats for interoperability with other applications.

The Image Processing module provides operations for manipulating images and volumes, including type conversion, color conversion, contrast adjustment, filtering, morphology, connected components, region measurements, geometric transforms, resizing, rotation, feature detection, foundational 3-D processing, and image registration.

Help pages are grouped into topic chapters: image basics, image analysis and segmentation, and geometry, registration, and 3-D processing.

The WebTools module provides functions to interact with web resources, transfer data via URLs, and work with RESTful web services.

The WebView module opens local HTML, inline HTML text, web addresses and the examples gallery from Nelson.

The Dynamic Link module enables Nelson to build, load, and call C/C++ and Fortran code at runtime.

It supports generating gateways, loaders, and managing shared libraries for integration with external compiled code.

By default, Nelson does not try to detect a C/C++ compiler on Windows. Do not forget to run 'configuremsvc' or 'configuremingw' once.