Representation of grossone-based arithmetic in simulink for scientific computing

In the Infinity Computing framework [see Sergeyev (2017)], all numbers are represented using the positional numeral system with the infinite radix \({\displaystyle {{\textcircled {1}}}}\) introduced as the number of elements of the set of natural numbers [see, e.g., Sergeyev (2017)]:where quantities \(d_i,~i=0,\ldots ,n\), are finite (positive or negative) floating-point numbers called grossdigits, and \(p_i,~i=0,\ldots ,n\), are called grosspowers and can be finite, infinite and infinitesimal (positive or negative), n is the number of grosspowers used in computations (can be fixed or variable for all computations)¹. Due to limitations of the Simulink (e.g., difficulties in working with variable-sized matrices in algebraic loops) and for simplicity, only finite floating-point grosspowers are considered in this paper. It should be noted that this methodology is not related to non-standard analysis [see Sergeyev (2019) for details].

One can see that a finite floating-point number A can be easily expressed in this framework using only one grosspower \(p_0 = 0:\) \(A = A{\displaystyle {{\textcircled {1}}}}^{0}\). Moreover, different infinite and infinitesimal numbers can be also expressed: e.g., the numbers \({\displaystyle {{\textcircled {1}}}}\), \({\displaystyle {{\textcircled {1}}}}^{2}\), \(-1.5{\displaystyle {{\textcircled {1}}}}^{2.5}\), \(-1.2{\displaystyle {{\textcircled {1}}}}^{3.2}-1.2{\displaystyle {{\textcircled {1}}}}^{0}+2.3{\displaystyle {{\textcircled {1}}}}^{-1.2}\) are infinite, since they contain at least one finite positive grosspower, while the numbers \({\displaystyle {{\textcircled {1}}}}^{-1} = \frac{1}{{\displaystyle {{\textcircled {1}}}}}\), \(2.5{\displaystyle {{\textcircled {1}}}}^{-1.5}\), \(1.3{\displaystyle {{\textcircled {1}}}}^{-2.2}-1.7{\displaystyle {{\textcircled {1}}}}^{-3.1}\) are infinitesimal, since they contain only finite negative grosspowers. Let us call the numbers expressed in the form (1) as grossnumbers hereinafter.

The Infinity Computer has been already successfully used for solving problems in applied mathematics, e.g., in optimization [see Cococcioni et al. (2020b, (2018); De Cosmis and De Leone (2012); De Leone (2018); De Leone et al. (2018); Gaudioso et al. (2018); Sergeyev et al. (2018)], infinite series [see Zhigljavsky (2012)], game theory and probability [see Calude and Dumitrescu (2020a); Fiaschi and Cococcioni (2018); Rizza (2019)], fractals and cellular automata [see Caldarola (2018); D’Alotto (2015); Sergeyev (2011b, (2016)], numerical differentiation and ordinary differential equations [see Amodio et al. (2016); Falcone et al. (2020b); Iavernaro et al. (2019); Sergeyev (2011a, (2013); Sergeyev et al. (2016)], etc.

Simulink is a software developed by MathWorks as extension of MATLAB [see MathWorks (2019a)]. It allows engineers to rapidly build, simulate and analyze dynamic systems using block diagram notation before moving to hardware. Moreover, Simulink offers a graphical support that shows the progress of a simulation, significantly increasing understanding of the system’s behavior.

The potential productivity improvement achieved with Simulink to programming is impressive [see Falcone and Garro (2019); MathWorks (2019a)]. In the past, the common approach to develop a system was to start from its components by describing their logic through blocks. Then, blocks were translated into the corresponding source code according to a given programming language (e.g., C/C++). This approach involved duplication of effort, since the system had to be described twice; the first time using block notation and then in a programming language. This practice exposed to accuracy risks in the translation process from blocks to source code, making debugging phases difficult because errors could be in the design (block diagram level), in the programming (programming level), and/or in the translation process. With Simulink, this approach is no longer necessary since blocks are the “program”.

Simulink is widely used in research and industry to explore and analyze different design alternatives of complex system in order to find the best configuration that meets the requirements. Research teams can exploit the multi-domain nature of Simulink to collaboratively simulate the behavior of the system’s components, each of which developed by a team, also to understand how components influence the behavior of the entire system Falcone and Garro (2016a); Falcone et al. (2017a, (2017b, (2018a).

Simulink allows one: to reduce expensive prototypes by testing the system in otherwise risky and/or time-consuming conditions; to validate the system design with hardware-in-the-loop testing and rapid prototyping; and to maintain traceability of requirements from design down to the corresponding source code.

The presented Simulink-based solution is general-purpose and domain-independent; as a consequence, it can be exploited in all industrial and scientific domains where a high level of accuracy in the calculations represents a mainstay (e.g., Cyber-Physical Systems, Robotics and Automation, Aerospace [see Falcone and Garro (2018); Falcone et al. (2017b); Garro et al. (2015, (2018b)]).

The design and implementation of the solution have been focused on standard software engineering methods and techniques, in particular, on the Agile software development process [see Martin (2002); Venkatesh et al. (2020)]. The solution has been developed through the use of standard Simulink Blocks and S-Functions, which allows engineers to jointly exploit the advantages coming from the Infinity Computer and the already available Simulink functionalities. Figure 1 presents an overview of the Simulink-based Infinity Computing solution and its integration with the MATLAB/Simulink environments.

In the following Fig. 1, the Simulink-based solution is placed in the middle of three layers.

The Simulink UI represents the Simulink environment used for modeling, analyzing and simulating dynamic systems through the graphical block diagramming tool according to the Model-Based Design (MBD) paradigm [see Falcone and Garro (2017b)]. MBD offers an efficient approach to address problems associated with the design and implementation of complex systems, signal processing equipment and communication components. This approach provides a common framework where engineers can define models with advanced functionalities using continuous-time and discrete-time blocks. The so-obtained models can be simulated in Simulink by using different operational conditions leading to rapid prototyping, testing and verification of the system’s requirements and performances.

The Simulink Environment layer provides all the standard Simulink blocks along with the ones offered by the Simulink-based Infinity Computer solution (details will be given in Subsection 3.3).

In the Simulink-based solution of the Infinity Computer, a grossnumber x is represented through a standard Simulink Constant block as a variable-sized vector (1-D array) or matrix (2-D array) depending on the dimensionality of the “Constant value” parameter [see MathWorks (2019a)]. Specifically, the output has the same dimensions and elements as the “Constant value” parameter. If “Constant value” is a vector and “Interpret vector parameters as 1-D” is enabled, Simulink treats the output as a 1-D array; otherwise, the output is managed as a matrix (i.e., a 2-D array). Regardless of the output size, the first column represents the grossdigits, whereas the second one defines the grosspowers of a number written in the form (1): the number (1) is represented by the following matrix:For instance, the number 2 is represented in this solution through a vector \(\left[ \begin{matrix} 2&0 \end{matrix}\right] \), while the number \(5{\displaystyle {{\textcircled {1}}}}^{0}+1{\displaystyle {{\textcircled {1}}}}^{-1}\) is represented by the matrix \(\left[ \begin{matrix} 5 &{} 0\\ 1 &{} -1 \end{matrix}\right] \).

A set of functional blocks have been created to manage computations on infinite, finite, and infinitesimal quantities written in the form (2) that each functional block takes as input infinite, finite, and infinitesimal quantities that are forwarded to the associated S-Function to perform the computation by interacting with ICA-lib. Figure 2 shows the functional block modules that constitute the Simulink-based Infinity Computer solution.

In this subsection, the following three test functions from Sergeyev et al. (2016) are considered:These functions have been chosen among the 24 test functions from Sergeyev et al. (2016) for the following reasons. First, they contain different elementary functions: \(f_1(x)\) is rational, \(f_2(x)\) is trigonometric, \(f_3(x)\) contains the exponential function. Second, these functions are simple to implement for a fast visualization, do not contain a lot of blocks of the same type or algebraic loops. Finally, all these functions are infinitely differentiable.

In Figs. 5, 6, and 7, the implementations of the functions \(f_i,~i=1,2,3,\) are presented using the proposed solution (a) and using standard Simulink blocks (b). One can see that these implementations are straightforward and simular. A unique difference consists of the block toGross, which transforms the input x from the traditional computational framework to the form (2) and the block getFinitePart, which returns the finite part of the result f(x). The utility blocks have been added in these implementations only to keep the computations in the traditional computational framework outside the functions, which can be useful in practice (so, there is no necessity to re-write all the implementations of the systems to the presented solution; this solution is used only where it is necessary). One can see from this figure, that the implementation of the functions in the proposed solution does not require a lot of additional knowledge about the Infinity Computer or about the low-level implementations of the Infinity Computer arithmetic. The number of the used blocks is the same, so there is no additional costs in implementation of the functions (except the addition of the utility blocks at the initial and final parts of the Simulink system, which has a constant complexity). One can see also that the results of the computation of these two implementations of the test functions at the points \(x_i^*,~i=1, 2, 3,\) from Sergeyev et al. (2016) also coincide (the points \(x_i^*\), which are the global minimizers of the functions \(f_i(x)\), respectively, have been chosen just for simplicity: the results of the computations at any finite point \(x_0\) coincide for these two implementations).

Let us now evaluate these functions at the inputs given as the grossnumbers, i.e., without the utility blocks toGross and getFinitePart. In Fig. 8, the results of the computation at two different points \(x_1 = 3{\displaystyle {{\textcircled {1}}}}^{0}+1.5{\displaystyle {{\textcircled {1}}}}^{-1}\) (on the left side) and \(x_2 = 2.5{\displaystyle {{\textcircled {1}}}}^{-1.5}-3.6{\displaystyle {{\textcircled {1}}}}^{-2}+5{\displaystyle {{\textcircled {1}}}}^{-3.2}\) (on the right side) are presented. The computations are kept with the precision \(n = 5\), i.e., using 5 grosspowers in (1). One can see that computations with different grossnumbers are allowed in this solution. Moreover, the grosspowers are not necessarily integer, but can be different floating-point numbers, as well. It is very important that the user could not know how the arithmetic operations are implemented inside the functions f(x). Namely, it is sufficient to give an input x and the output f(x) will be automatically generated in the form (1) without the necessity to deal with the \(C++\) class of the Infinity Computer simulator.

Let us consider now an important application of the proposed solution in the numerical analysis field. Suppose that we want to calculate the first \(k,~k\ge 1,\) derivatives of the function f(x) implemented using the Simulink arithmetic blocks. Traditionally [see Karris (2006b)], the internal Simulink block “Derivative” allows one to calculate the derivatives only using the finite forward differences, which are usually not accurate. Moreover, since using the forward differences for computation of the first \(k,~k\ge 1,\) derivatives, at least \(k+1\) observations of the function f(x) are needed, then the values of the derivatives at the first \(x_0,\) \(x_1,\) ...\(,x_{k-1}\) points cannot be calculated using the Simulink’s “derivative” blocks. The obtained error is of order 1, i.e., proportional to the Simulink’s system sample time \(\Delta t\), and often cannot be small enough due numerical cancellation errors.

Another possibility to calculate the exact higher-order derivatives in Simulink is using external packages, e.g., for automatic differentiation. However, this solution has several disadvantages. First, using external packages requires additional knowledge on how they work and how to use them. Second, if the function f(x) is difficult and uses a lot of subsystems and external dependencies, then the resulting formulae or systems obtained by the automatic differentiation can be too difficult and can require a lot of computational resources to generate them. Moreover, in this case, the evaluation of the higher-order derivatives can be too slow or even impossible [see, e.g., Iavernaro et al. (2020a)].

Let us see, how the higher-order derivatives can be calculated on the Infinity Computer. Suppose that the function f(x) has only finite values at the finite points x (i.e., it does not depend on \({\displaystyle {{\textcircled {1}}}}\)). Suppose also that there exists the (unknown) Taylor expansion of the function f(x) around the finite point \(x_0\). Then, the result of the computation of f(x) at the point \(x_0 + {\displaystyle {{\textcircled {1}}}}^{-1}\) truncated after \(k+1\) grosspowers gives us the exact² higher-order derivatives of the function f(x) at the point \(x_0\):from where one can obtain that \(f(x_0) = f_0,\) \(f'(x_0) = f_1,\) \(f''(x_0) = f_2 \cdot 2!,\)..., \(f^{(k)}(x) = f_k \cdot k!\) [see Sergeyev (2011a, (2017) for details].

In Fig. 9, the Simulink subsystem for computation of the first 2 derivatives of a function f(x) implemented in the subsystem “f(x)” at the time steps t using the proposed solution of the Infinity Computer is presented. Since the derivative is calculated with respect to the time t, then let us call the functions f(x) as the functions depending on time t, i.e., f(t), hereinafter. First, the input t given by the standard Simulink block “clock” is transformed to the grossnumber \(t_{gross}\) by the block “toGross”. Then, the infinitesimal \({\displaystyle {{\textcircled {1}}}}^{-1}\) expressed by the constant block is added to the transformed input \(t_{gross}\). The obtained grossnumber is moved to the input of the block “f(x)”. The output of the block “f(x)” is multiplied by \({\displaystyle {{\textcircled {1}}}}\) and the result arrives to the block “getFinitePart” (from where the value \(f'(t)\) is obtained), at the same time the output of the block “f(x)” is multiplied by \(2{\displaystyle {{\textcircled {1}}}}^{2}\) and the result arrives to the block “getFinitePart” as well (from where the value \(f''(t)\) is obtained). The obtained values of the derivatives arrive to the scope blocks in order to construct their graphs.

The graphs of the first two derivatives for each test function \(f_i(t),~i=1,2,3,\) from (10) to (12) are presented in Fig. 10, from where one can see that the derivatives obtained by the Infinity Computer coincide with the exact derivatives obtained analytically.

One can see that the differentiation using the presented solution is simple and almost does not require any additional knowledge and/or tools. Higher-order derivatives can be easily calculated using only the proposed blocks without the necessity of an additional specific tool or block. More applications are provided in the accompanying paper [see Falcone et al. (2020a)].