v1.8.0

Author: Nelson-numerical-software

en/README.md

@@ -1,96 +1,84 @@
 ![banner](banner_homepage.png)
 
-### Nelson 1.7.0.0
+### Nelson 1.8.0.0
 
-Nelson is an interactive, fully functional environment for engineering and scientific applications. It implements a matrix-driven language (which is largely compatible with MATLAB and GNU Octave), with advanced features such as 2-D 3-D plotting, image manipulation and viewing, a codeless interface to external C/C++/FORTRAN libraries, native support for various C types, and a host of other features.
+Nelson is a powerful, open-source numerical computational language, developed to provide a comprehensive and intuitive environment for engineers, scientists, and students. With over 1,200 built-in functions, Nelson supports a wide range of tasks, from basic algebra to advanced numerical simulations.
 
-Try it !
+Originally inspired by languages like MATLAB© and GNU Octave, Nelson offers users a lightweight yet feature-rich experience. It is designed to be easy to learn and use, with an emphasis on performance and flexibility.
 
-[Web site](https://nelson-lang.github.io/nelson-website/)
+**Try it now!**
 
-## Features
-
-- Types managed by Nelson:
-
-  - double and double complex: scalar, vector, matrix 2D, N dimensions array, sparse matrix.
-  - single and single complex: scalar, vector, matrix 2D, N dimensions array, sparse matrix.
-  - logical: scalar, vector, matrix 2D, N dimensions array, sparse matrix.
-  - character array (UNICODE supported).
-  - string array (UNICODE supported).
-  - integers 8, 16, 32, 64 signed and unsigned: scalar, vector, matrix 2D, N dimensions array.
-  - handle objects.
-  - anonymous functions,
-  - all types can be overloaded.
-
-- `OpenMP` and `SIMD` extensions used.
-
-- 2D and 3D plotting with high-level plot commands.
-
-- Desktop environment with history, file and workspace browser.
-
-- Parallel Computing Module.
-
-- Fast Fourrier Transformation functions based on FFTW and MKL wrapper.
-
-- SLICOT (Subroutine Library in Systems and Control Theory) interfaces (optional).
+[Site Web](https://nelson-lang.github.io/nelson-website/)
 
-- Control System module.
-
-- Message Passing Interface (MPI): functions for parallel computing.
-
-- JSON decode/encode data support.
-
-- HDF5 high-level functions I/O,
-
-- HDF5 used as default data file format (.nh5) load/save workspace,
-
-- MAT-file compatible load/save workspace,
-
-- Foreign Function Interface C/Fortran.
-
-- Interfacing C/C++ or Fortran with Nelson (build and load external code on the fly).
-
-- MEX C API compatibility.
+## Features
 
-- Call Python from Nelson.
+### Data Types Managed by Nelson
 
-- Nelson Engine API for C (compatible with MEX Engine). Call Nelson from your C code as engine.
+- **Double and Complex Double**: Supports scalars, vectors, 2D matrices, N-dimensional arrays, and sparse matrices.
+- **Single and Complex Single**: Includes scalars, vectors, 2D matrices, N-dimensional arrays, and sparse matrices.
+- **Logical**: Handles scalars, vectors, 2D matrices, N-dimensional arrays, and sparse matrices.
+- **Character Arrays**: Supports UNICODE characters.
+- **String Arrays**: Fully supports UNICODE.
+- **Integers**: 8, 16, 32, and 64-bit signed and unsigned scalars, vectors, 2D matrices, and N-dimensional arrays.
+- **Handle Objects**: For object-oriented functionality.
+- **Anonymous Functions**: Allows creation and manipulation of functions without names.
+- **Data Structures**: Supports dictionaries and tables.
+- **Overloading**: All types can be overloaded for custom behavior.
 
-- RESTful API web service.
+### Performance Enhancements
 
-- Inter-process communication between Nelson's process.
+- **OpenMP and SIMD**: Utilizes parallel processing and vectorization for faster computations.
 
-- The QML engine enables nelson programs to display and manipulate graphical content using Qt's QML framework.
+### Visualization & Interface
 
-- Component Object Model (COM) client interface: binary-interface standard for software components on Windows.
+- **2D and 3D Plotting**: High-level commands for visualizations.
+- **User Interface Controls**: Built-in controls for creating custom interfaces.
+- **Desktop Environment**: Comes with history tracking, a file explorer, and workspace browser.
 
-- Write/Read xlsx files on Windows using COM.
+### Advanced Modules
 
-- Embedded Nelson code editor.
+- **Parallel Computing**: Enables efficient use of multi-core processors.
+- **Fast Fourier Transform (FFT)**: High-performance FFT functions based on FFTW and MKL.
+- **SLICOT Interface**: Optional support for the Systems and Control Theory subroutine library.
+- **Control System Module**: Tools for control theory and system design.
+- **MPI (Message Passing Interface)**: Functions for distributed parallel computing.
 
-- Help engine:
+### Data Formats & Interfacing
 
-  Generate help files using Nelson dedicated functions.
-  View your generated help files as html, markdown, pdf, gitbook or directly in Nelson help viewer.
+- **JSON Support**: Read and write JSON files.
+- **HDF5 Functions**: High-level I/O functions, with HDF5 as the default file format for `.nh5` workspaces.
+- **MAT-File Compatibility**: Load and save workspaces in MAT-file format.
+- **Foreign Function Interface (FFI)**: Build and load C/Fortran code on the fly.
+- **MEX C API Compatibility**: Interfacing with MEX-compatible C APIs.
+- **Nelson Engine API**: Use Nelson as a backend engine within C code, compatible with the MEX Engine API.
+- **Python Interfacing**: Call Python scripts and functions from Nelson.
+- **RESTful API**: Enables Nelson to interact with web services.
 
-- Tests engine:
+### Additional Capabilities
 
-  Validate your algorithm using Nelson dedicated functions.
-  Export the test results under the xUnit reports format.
+- **Inter-Process Communication**: Communicate between Nelson processes.
+- **QML Engine**: Use Qt’s QML framework to display and manipulate graphical content.
+- **Component Object Model (COM)**: Interface with COM components, especially on Windows.
+- **Excel File Support**: Write and read `.xlsx` files using COM on Windows.
+- **Embedded Code Editor**: Integrated editor for Nelson scripts.
 
-- Profiling and Code coverage tools for Nelson's language:
+### Help & Testing Tools
 
-  Nelson has a built-in profiler that is very useful to profile your code and find out what script or function is taking the most time.
+- **Help Engine**: Generate and view help files in various formats like HTML, Markdown, PDF, or GitBook.
+- **Test Engine**: Validate algorithms using built-in functions, with support for xUnit report export.
 
-- [Nelson cloud](https://www.npmjs.com/package/nelson-cloud):
-  Instant access to Nelson anywhere from an web browser.
+### Profiling & Code Coverage
 
-- Module skeleton to extend Nelson available here:
+- **Profiler**: Built-in profiler to analyze and optimize code performance.
+- **Code Coverage**: Measure the coverage of your tests to ensure thorough validation.
 
-  - [template macros and builtin](https://github.com/nelson-lang/module_skeleton),
-  - [basic template macros only](https://github.com/nelson-lang/module_skeleton_basic).
+### Cloud & Extensibility
 
-- Nelson Modules Manager (nmm) : package manager for Nelson
+- **Nelson Cloud**: Instant access to Nelson from any web browser via [Nelson Cloud](https://www.npmjs.com/package/nelson-cloud).
+- **Module Skeleton**: Templates for extending Nelson:
+  - [Template with Macros and Builtins](https://github.com/nelson-lang/module_skeleton).
+  - [Basic Macros Template](https://github.com/nelson-lang/module_skeleton_basic).
+- **Nelson Modules Manager (nmm)**: A package manager to install and manage extensions for Nelson.
 
 ---
 

en/SUMMARY.md

@@ -208,6 +208,20 @@
   - [types](./dictionary/types.md)
   - [values](./dictionary/values.md)
 
+- [table](./table/README.md)
+
+  - [Accessing and Manipulating Tables in Nelson](./table/accessing_manipulating_table.md)
+  - [array2table](./table/array2table.md)
+  - [cell2table](./table/cell2table.md)
+  - [height](./table/height.md)
+  - [istable](./table/istable.md)
+  - [struct2table](./table/struct2table.md)
+  - [table](./table/table.md)
+  - [table2array](./table/table2array.md)
+  - [table2cell](./table/table2cell.md)
+  - [table2struct](./table/table2struct.md)
+  - [width](./table/width.md)
+
 - [integer](./integer/README.md)
 
   - [int16](./integer/int16.md)
@@ -707,6 +721,7 @@
   - [cputime](./time/cputime.md)
   - [date](./time/date.md)
   - [datenum](./time/datenum.md)
+  - [datestr](./time/datestr.md)
   - [datevec](./time/datevec.md)
   - [eomday](./time/eomday.md)
   - [etime](./time/etime.md)

en/changelogs/CHANGELOG.md

@@ -5,7 +5,51 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 1.7.0 (2024-08-27)
+## 1.8.0 (2024-10-04)
+
+### Added
+
+- **`table` Data Type**:
+
+  - Introduced the `table` data type, offering enhanced functionality for structured data manipulation.
+
+  - Overloaded methods specific to the `table` data type:
+
+    - `disp`, `display` for table display.
+    - `horzcat`, `vertcat` for horizontal and vertical concatenation.
+    - `isempty` to check if the table is empty.
+    - `isequal`, `isequalto` for table comparison.
+    - `properties` for accessing table metadata.
+    - `subsasgn` for subscripted assignment.
+    - `subsref` for subscripted referencing.
+
+  - Conversion functions added:
+
+    - `array2table`: Convert an array to a table.
+    - `cell2table`: Convert a cell array to a table.
+    - `struct2table`: Convert a structure to a table.
+    - `table2array`: Convert a table to an array.
+    - `table2cell`: Convert a table to a cell array.
+    - `table2struct`: Convert a table to a structure.
+
+  - Utility functions introduced:
+    - `width`: Retrieve the number of columns in the table
+    - `height`: Retrieve the number of rows in the table
+    - `istable`: Check if a variable is of the `table` data type
+
+- `Resize` - Resize figure property.
+- [#36](http://github.com/nelson-lang/nelson/issues/36) `datenum` format compatibility extended.
+- [#37](http://github.com/nelson-lang/nelson/issues/37) `datestr` Convert date and time to string format.
+
+### Changed
+
+- CodeQL Github action updated.
+
+### Fixed
+
+- fix 'units' refresh for 'axes' object.
+
+## 1.7.0 (2024-08-28)
 
 ### Added
 

en/graphics/figure.md

@@ -43,6 +43,7 @@ Creates an figure window.
   <p><b>Parent</b>: Figure parent: root graphics object.</p>
   <p><b>Position</b>: Location and size of drawable area: [left, bottom, width, height]</p>
   <p>'width' and 'height' define the size of the window. 'left' and 'bottom' define the position of the first addressable pixel in the lower left corner of the window</p>
+  <p><b>Resize</b>: Resize figure: 'on' or 'off' (default).</p>
   <p><b>Tag</b>: Object identifier: string scalar, character vector, '' (default).</p>
   <p><b>ToolBar</b>:  Figure toolbar display: 'none', 'auto' (default), 'figure'.</p>
   <p><b>Type</b>: Type 'figure'.</p>
@@ -81,6 +82,7 @@ figure('Name', 'Hello')
 | 1.2.0   | Clicking on an figure automatically sets it as the current figure object.                        |
 | 1.7.0   | CreateFcn, DeleteFcn, CloseRequestFcn, KeyPressFcn, KeyReleaseFcn, ButtonDownFcn callback added. |
 | --      | BeingDeleted property added.                                                                     |
+| 1.8.0   | Resize property added.                                                                           |
 
 ## Author
 

en/table/README.md

@@ -0,0 +1,19 @@
+# Tables
+
+Tables
+
+## Description
+
+Tables of arrays with named columns, each potentially containing different data types.
+
+- [Accessing and Manipulating Tables in Nelson](accessing_manipulating_table.md)
+- [array2table](array2table.md) - Convert homogeneous array to table.
+- [cell2table](cell2table.md) - Convert cell array to table.
+- [height](height.md) - Number of table rows
+- [istable](istable.md) - Determine if input is table.
+- [struct2table](struct2table.md) - Convert a structure array into a tabular format.
+- [table](table.md) - A table-like array with named variables, capable of holding different data types
+- [table2array](table2array.md) - Convert table to homogeneous array.
+- [table2cell](table2cell.md) - Convert table to cell array
+- [table2struct](table2struct.md) - Convert table to structure array
+- [width](width.md) - Number of table variables

en/table/SUMMARY.md

@@ -0,0 +1,12 @@
+- [table](README.md)
+  - [Accessing and Manipulating Tables in Nelson](accessing_manipulating_table.md)
+  - [array2table](array2table.md)
+  - [cell2table](cell2table.md)
+  - [height](height.md)
+  - [istable](istable.md)
+  - [struct2table](struct2table.md)
+  - [table](table.md)
+  - [table2array](table2array.md)
+  - [table2cell](table2cell.md)
+  - [table2struct](table2struct.md)
+  - [width](width.md)