Nelson: Scientific Computing Environment Programming Language.
Nelson is an open-source scientific computing environment designed for numerical analysis, data visualization, and algorithm development.
Built for performance and ease of use, Nelson provides a comprehensive suite of mathematical functions, advanced data structures, and powerful visualization tools.
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, 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 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.
This module ensures that users can manage execution flow in the presence of failures, capture meaningful error reports, and display warnings without interrupting program execution.
It forms the foundation for robust error handling and debugging in Nelson applications.
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 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 includes functionality for detecting character sets that match a given input, facilitating reliable 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 ensures that Nelson can be adapted to different linguistic and regional preferences, supporting a multilingual user experience.
The i18n module provides tools for internationalization and localization of text within Nelson.
It enables retrieval of translated strings for the current locale, supports utilities for managing translation workflows, and facilitates the generation of 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 allows users to query the nature of variables, distinguish between numeric, logical, string, and object types, 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.
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 comprehensive tools 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.
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 facilitates flexible handling of complex data, supporting both 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.
The Overloading module provides mechanisms for customizing the behavior of functions and operators in Nelson.
It allows users to define how standard operations or built-in functions should 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 a wide range of 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 a comprehensive set of functions for performing 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.
Additionally, the module offers utility functions for converting between degrees and radians, facilitating seamless integration of trigonometric calculations into various mathematical and engineering applications.
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 comprehensive tools for performing matrix and vector computations in Nelson.
It includes functions for matrix factorization, decomposition, inversion, and analysis, as well as operations on eigenvalues, singular values, and subspaces.
The module supports advanced numerical methods for evaluating matrix properties, condition numbers, and transformations, enabling efficient and accurate solutions for a wide range of 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 enables efficient processing, summarization, and exploration of datasets, facilitating a wide range of computational and analytical tasks.
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, enabling the construction of transformation matrices for manipulating objects and coordinate systems.
This module is useful for applications in computer graphics, robotics, 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 functionality for system balancing, controllability and observability analysis, regulator and estimator design, and simulation of dynamic system responses.
These tools enable robust modeling, analysis, and control of linear dynamic systems for engineering and research applications.
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 and manipulating sampled signals in Nelson.
It includes windowing functions, digital filtering, cross-correlation, and conversions between magnitude, power, and decibel representations.
The module also supports transformation between zero-pole representations and transfer functions, enabling efficient design and analysis of discrete-time signal processing systems.
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 enables seamless integration of Nelson scripts with the underlying operating system across 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 enables memory inspection, variable locking, and listing of workspace contents, facilitating efficient and 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 enables logging of session activity, and loading and saving workspace data, facilitating robust and flexible file I/O operations within scripts and applications.
The HDF5 module provides support for working with Hierarchical Data Format (HDF5) files in Nelson.
It allows users to create datasets, read and write data and attributes, and explore 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 provides support for reading and writing MAT-files, a widely used format for storing numerical data in MATLAB© and compatible environments.
It enables Nelson to check MAT-file validity, load and save workspace variables, and inspect file contents.
With this module, users can exchange data between Nelson and MATLAB©, making it a key component for interoperability 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 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.
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 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 basic operations for manipulating images, including format conversion, resizing, and rotation.
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 WebTools module provides functions to interact with web resources, transfer data via URLs, and work with RESTful web services.
It provides functions for managing connections, sending and receiving data, and handling events in a cloud environment.
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.
The MEX (MATLAB Executable) module allows C/C++ code to interface with Nelson, extending its functionality and enabling access to Nelson’s engine, variables, and functions.
The F2C module allows Nelson users to convert legacy Fortran 77 source files into C code.
This enables seamless integration of older Fortran routines into Nelson workflows, supporting compilation, execution, and interaction with Nelson variables.
It is particularly useful for leveraging existing numerical algorithms or legacy scientific codebases within a modern Nelson environment.
The NIG module provides tools to easily interface C or Fortran functions with Nelson.
It simplifies the process of creating gateways that allow compiled routines to be called directly from Nelson scripts or functions, enabling high-performance computation and reuse of existing numerical libraries.
The Validators module provides tools for enforcing constraints and verifying input values in Nelson.
It supports checking data types, numerical properties, matrix and vector dimensions, text validity, file and folder existence, and logical or numeric conditions.
This module ensures robust input validation, helping to prevent errors, enforce correctness, and improve the reliability of scripts and functions.
The COM Engine module allows Nelson to interact with Windows COM (Component Object Model) and ActiveX components.
It enables automation of software applications, access to their methods and properties, and manipulation of COM objects directly from Nelson scripts.
This provides a way to integrate Nelson with a wide range of Windows software, including Microsoft Office applications.
The Python Engine module allows Nelson users to seamlessly interface with Python, leveraging Python’s extensive ecosystem alongside Nelson’s native capabilities.
It provides functions to run Python code, manage interpreter environments, and exchange data between Nelson and Python.
The Julia Engine module enables Nelson users to seamlessly interface with the Julia programming language, combining Julia's high-performance numerical capabilities with Nelson's environment.
It provides functions to run Julia code, manage interpreter environments, and exchange data between Nelson and Julia.
The History Manager module in Nelson provides tools to access and manage the command history of your session.
It allows users to review previously executed commands, recall them for reuse, and maintain an organized workflow.
The Debugger module in Nelson provides functions to inspect and analyze program execution.
It is designed to help users identify errors, trace the flow of execution, and better understand the state of variables during runtime.
The Profiler module in Nelson provides functions to measure and analyze the execution performance of code.
It helps users identify bottlenecks, optimize slow parts of programs, and improve overall efficiency.
The Test Manager module in Nelson provides tools for automated testing of code, enabling users to validate functionality, ensure correctness, and manage test cases efficiently.
This module supports creating reference outputs, running test suites, and conditionally skipping tests.
The Asserts Functions module in Nelson provides tools for validating program behavior and verifying conditions during development or testing.
These functions help ensure that computations and logical conditions meet expected criteria, improving code reliability and catching errors early.
The Help Tools module provides functions to create, convert, and manage documentation for Nelson.
It supports generating help content in multiple formats, including HTML, Markdown, PDF, and website-ready formats, enabling developers to maintain and distribute comprehensive documentation efficiently.